leaflet-js 0.7.9 → 0.8.dev2

data/lib/leaflet/spec/spec.hintrc.js

@@ -0,0 +1,25 @@
+{
+	"browser": true,
+	"node": true,
+	"predef": ["define", "L", "expect", "describe", "it", "sinon", "happen", "beforeEach", "afterEach"],
+	"strict": false,
+	"bitwise": true,
+	"camelcase": true,
+	"curly": true,
+	"eqeqeq": true,
+	"forin": false,
+	"immed": true,
+	"latedef": true,
+	"newcap": true,
+	"noarg": true,
+	"noempty": true,
+	"nonew": true,
+	"undef": true,
+	// "unused": true,
+	// "quotmark": "single",
+	"indent": 4,
+	"trailing": true,
+	"white": true,
+	"smarttabs": true
+	// "maxlen": 120
+}

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

@@ -0,0 +1,42 @@
+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);
+		// jshint bitwise: false
+		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;
+	};
+}
+
+expect.Assertion.prototype.near = function (expected, delta) {
+	delta = delta || 1;
+	expect(this.obj.x).to
+		.be.within(expected.x - delta, expected.x + delta);
+	expect(this.obj.y).to
+		.be.within(expected.y - delta, expected.y + delta);
+};
+
+expect.Assertion.prototype.nearLatLng = function (expected, delta) {
+	delta = delta || 1e-4;
+	expect(this.obj.lat).to
+		.be.within(expected.lat - delta, expected.lat + delta);
+	expect(this.obj.lng).to
+		.be.within(expected.lng - delta, expected.lng + delta);
+};

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,166 @@
+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.foo1).to.eql(1);
+			expect(a.options.foo2).to.eql(3);
+			expect(a.options.foo3).to.eql(4);
+		});
+
+		it("gives new classes a distinct options object", function () {
+			var K1 = L.Class.extend({options: {}});
+			var K2 = K1.extend({});
+			expect(K2.prototype.options).not.to.equal(K1.prototype.options);
+		});
+
+		it("inherits options prototypally", function () {
+			var K1 = L.Class.extend({options: {}});
+			var K2 = K1.extend({options: {}});
+			K1.prototype.options.foo = 'bar';
+			expect(K2.prototype.options.foo).to.eql('bar');
+		});
+
+		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,416 @@
+describe('Events', function () {
+
+	describe('#fireEvent', function () {
+
+		it('fires all listeners added through #addEventListener', function () {
+			var obj = new L.Evented(),
+				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 L.Evented(),
+				obj2 = new L.Evented(),
+				obj3 = new L.Evented(),
+				obj4 = new L.Evented(),
+				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 L.Evented(),
+				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 L.Evented();
+			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 L.Evented(),
+				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 L.Evented(),
+				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 L.Evented(),
+				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('removes listeners with context == this and a stamp originally added without one', function () {
+			var obj = new L.Evented(),
+				obj2 = new L.Evented(),
+				spy1 = sinon.spy(),
+				spy2 = sinon.spy(),
+				spy3 = sinon.spy();
+
+			obj.addEventListener('test', spy1, obj);
+			L.Util.stamp(obj);
+			obj.addEventListener('test', spy2, obj);
+			obj.addEventListener('test', spy3, obj2); // So that there is a contextId based listener, otherwise removeEventListener will do correct behaviour anyway
+
+			obj.removeEventListener('test', spy1, obj);
+			obj.removeEventListener('test', spy2, obj);
+			obj.removeEventListener('test', spy3, obj2);
+
+			obj.fireEvent('test');
+
+			expect(spy1.called).to.be(false);
+			expect(spy2.called).to.be(false);
+			expect(spy3.called).to.be(false);
+		});
+
+		it('doesnt lose track of listeners when removing non existent ones', function () {
+			var obj = new L.Evented(),
+			    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);
+		});
+
+		it('correctly removes all listeners if given no fn', function () {
+			var obj = new L.Evented(),
+			    spy = sinon.spy(),
+			    foo = {},
+			    foo2 = {},
+			    foo3 = {};
+
+			obj.addEventListener('test', spy, foo2);
+			obj.addEventListener('test', spy, foo3);
+
+			obj.removeEventListener('test'); // Removes both of the above listeners
+
+			expect(obj.listens('test')).to.be(false);
+
+			//Add and remove a listener
+			obj.addEventListener('test', spy, foo2);
+			obj.removeEventListener('test', spy, foo2);
+
+			expect(obj.listens('test')).to.be(false);
+		});
+
+		it('makes sure an event is not triggered if a listener is removed during dispatch', function () {
+			var obj = new L.Evented(),
+			    spy = sinon.spy();
+
+			obj.addEventListener('test', function () { obj.removeEventListener('test', spy); });
+			obj.addEventListener('test', spy);
+			obj.fireEvent('test');
+
+			expect(spy.called).to.be(false);
+		});
+	});
+
+	describe('#on, #off & #fire', function () {
+
+		it('works like #addEventListener && #removeEventListener', function () {
+			var obj = new L.Evented(),
+				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 Klass = L.Evented.extend({
+				on: spy1,
+				off: spy2,
+				fire: spy3
+			});
+
+			var obj = new Klass();
+
+			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 L.Evented(),
+				otherObj = new L.Evented();
+
+			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 L.Evented(),
+				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 L.Evented(),
+				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 L.Evented(),
+                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 L.Evented(),
+				spy = sinon.spy(),
+				foo = {};
+
+			obj.once('test', spy, foo);
+
+			obj.fire('test');
+
+			expect(spy.called).to.be(true);
+		});
+	});
+
+	describe('addEventParent && removeEventParent', function () {
+		it('makes the object propagate events with to the given one if fired with propagate=true', function () {
+			var obj = new L.Evented(),
+				parent1 = new L.Evented(),
+				parent2 = new L.Evented(),
+				spy1 = sinon.spy(),
+				spy2 = sinon.spy();
+
+			parent1.on('test', spy1);
+			parent2.on('test', spy2);
+
+			obj.addEventParent(parent1).addEventParent(parent2);
+
+			obj.fire('test');
+
+			expect(spy1.called).to.be(false);
+			expect(spy2.called).to.be(false);
+
+			obj.fire('test', null, true);
+
+			expect(spy1.called).to.be(true);
+			expect(spy2.called).to.be(true);
+
+			obj.removeEventParent(parent1);
+
+			obj.fire('test', null, true);
+
+			expect(spy1.callCount).to.be(1);
+			expect(spy2.callCount).to.be(2);
+		});
+	});
+});