leaflet-js 0.6.beta4

data/lib/leaflet/spec/suites/layer/vector/PolylineGeometrySpec.js

@@ -0,0 +1,35 @@
+describe('PolylineGeometry', function() {
+
+	var c = document.createElement('div');
+	c.style.width = '400px';
+	c.style.height = '400px';
+	var map = new L.Map(c);
+	map.setView(new L.LatLng(55.8, 37.6), 6);
+
+	describe("#distanceTo", function() {
+		it("calculates distances to points", function() {
+			var p1 = map.latLngToLayerPoint(new L.LatLng(55.8, 37.6));
+			var p2 = map.latLngToLayerPoint(new L.LatLng(57.123076977278, 44.861962891635));
+			var latlngs = [[56.485503424111, 35.545556640339], [55.972522915346, 36.116845702918], [55.502459116923, 34.930322265253], [55.31534617509, 38.973291015816]]
+			.map(function(ll) {
+				return new L.LatLng(ll[0], ll[1]);
+			});
+			var polyline = new L.Polyline([], {
+				'noClip': true
+			});
+			map.addLayer(polyline);
+
+			expect(polyline.closestLayerPoint(p1)).to.be(null);
+
+			polyline.setLatLngs(latlngs);
+			var point = polyline.closestLayerPoint(p1);
+			expect(point).not.to.be(null);
+			expect(point.distance).to.not.be(Infinity);
+			expect(point.distance).to.not.be(NaN);
+
+			var point2 = polyline.closestLayerPoint(p2);
+
+			expect(point.distance).to.be.lessThan(point2.distance);
+		});
+	});
+});

data/lib/leaflet/spec/suites/layer/vector/PolylineSpec.js

@@ -0,0 +1,55 @@
+describe('Polyline', function() {
+
+	var c = document.createElement('div');
+	c.style.width = '400px';
+	c.style.height = '400px';
+	var map = new L.Map(c);
+	map.setView(new L.LatLng(55.8, 37.6), 6);
+
+	describe("#initialize", function() {
+		it("doesn't overwrite the given latlng array", function () {
+			var originalLatLngs = [
+				[1, 2],
+				[3, 4]
+			];
+			var sourceLatLngs = originalLatLngs.slice();
+
+			var polyline = new L.Polyline(sourceLatLngs);
+
+			expect(sourceLatLngs).to.eql(originalLatLngs);
+			expect(polyline._latlngs).to.not.eql(sourceLatLngs);
+		});
+	});
+
+	describe("#setLatLngs", function () {
+		it("doesn't overwrite the given latlng array", function () {
+			var originalLatLngs = [
+				[1, 2],
+				[3, 4]
+			];
+			var sourceLatLngs = originalLatLngs.slice();
+
+			var polyline = new L.Polyline(sourceLatLngs);
+
+			polyline.setLatLngs(sourceLatLngs);
+
+			expect(sourceLatLngs).to.eql(originalLatLngs);
+		});
+	});
+
+	describe("#spliceLatLngs", function () {
+		it("splices the internal latLngs", function () {
+			var latLngs = [
+				[1, 2],
+				[3, 4],
+				[5, 6]
+			];
+
+			var polyline = new L.Polyline(latLngs);
+
+			polyline.spliceLatLngs(1, 1, [7, 8]);
+
+			expect(polyline._latlngs).to.eql([L.latLng([1, 2]), L.latLng([7, 8]), L.latLng([5, 6])]);
+		});
+	});
+});

data/lib/leaflet/spec/suites/map/MapSpec.js

@@ -0,0 +1,244 @@
+describe("Map", function () {
+	var map,
+		spy;
+	beforeEach(function () {
+		map = L.map(document.createElement('div'));
+	});
+
+	describe("#remove", function () {
+		it("fires an unload event if loaded", function () {
+			var container = document.createElement('div'),
+			    map = new L.Map(container).setView([0, 0], 0),
+				spy = sinon.spy();
+			map.on('unload', spy);
+			map.remove();
+			expect(spy.called).to.be.ok();
+		});
+
+		it("fires no unload event if not loaded", function () {
+			var container = document.createElement('div'),
+			    map = new L.Map(container),
+				spy = sinon.spy();
+			map.on('unload', spy);
+			map.remove();
+			expect(spy.called).not.to.be.ok();
+		});
+
+		describe("corner case checking", function () {
+			it("throws an exception upon reinitialization", function () {
+				var container = document.createElement('div'),
+					map = new L.Map(container);
+				expect(function () {
+					new L.Map(container);
+				}).to.throwException(function(e) {
+					expect(e.message).to.eql("Map container is already initialized.");
+				});
+				map.remove();
+			});
+
+			it("throws an exception if a container is not found", function () {
+				expect(function () {
+					new L.Map('nonexistentdivelement');
+				}).to.throwException(function(e) {
+					expect(e.message).to.eql("Map container not found.");
+				});
+				map.remove();
+			});
+		});
+
+		it("undefines container._leaflet", function () {
+			var container = document.createElement('div'),
+			    map = new L.Map(container);
+			map.remove();
+			expect(container._leaflet).to.be(undefined);
+		});
+
+		it("unbinds events", function () {
+			var container = document.createElement('div'),
+			    map = new L.Map(container).setView([0, 0], 1),
+				spy = sinon.spy();
+
+			map.on('click dblclick mousedown mouseup mousemove', spy);
+			map.remove();
+
+			happen.click(container);
+			happen.dblclick(container);
+			happen.mousedown(container);
+			happen.mouseup(container);
+			happen.mousemove(container);
+
+			expect(spy.called).to.not.be.ok();
+		});
+	});
+
+	describe('#getCenter', function () {
+		it ('throws if not set before', function () {
+			expect(function () {
+				map.getCenter();
+			}).to.throwError();
+		});
+	});
+
+	describe("#whenReady", function () {
+		describe("when the map has not yet been loaded", function () {
+			it("calls the callback when the map is loaded", function () {
+				var spy = sinon.spy();
+				map.whenReady(spy);
+				expect(spy.called).to.not.be.ok();
+
+				map.setView([0, 0], 1);
+				expect(spy.called).to.be.ok();
+			});
+		});
+
+		describe("when the map has already been loaded", function () {
+			it("calls the callback immediately", function () {
+				var spy = sinon.spy();
+				map.setView([0, 0], 1);
+				map.whenReady(spy);
+
+				expect(spy.called).to.be.ok();
+			});
+		});
+	});
+
+	describe("#setView", function () {
+		it("sets the view of the map", function () {
+			expect(map.setView([51.505, -0.09], 13)).to.be(map);
+			expect(map.getZoom()).to.be(13);
+			expect(map.getCenter().distanceTo([51.505, -0.09])).to.be.lessThan(5);
+		});
+	});
+
+	describe("#getBounds", function () {
+		it("is safe to call from within a moveend callback during initial load (#1027)", function () {
+			map.on("moveend", function () {
+				map.getBounds();
+			});
+
+			map.setView([51.505, -0.09], 13);
+		});
+	});
+
+	describe("#getMinZoom and #getMaxZoom", function () {
+		it("minZoom and maxZoom options overrides any minZoom and maxZoom set on layers", function () {
+			var c = document.createElement('div'),
+			    map = L.map(c, { minZoom: 5, maxZoom: 10 });
+			L.tileLayer("{z}{x}{y}", { minZoom:0, maxZoom: 10 }).addTo(map);
+			L.tileLayer("{z}{x}{y}", { minZoom:5, maxZoom: 15 }).addTo(map);
+			expect(map.getMinZoom()).to.be(5);
+			expect(map.getMaxZoom()).to.be(10);
+		});
+	});
+
+	describe("#addLayer", function () {
+		describe("When the first layer is added to a map", function () {
+			it("fires a zoomlevelschange event", function () {
+				var spy = sinon.spy();
+				map.on("zoomlevelschange", spy);
+				expect(spy.called).not.to.be.ok();
+				L.tileLayer("{z}{x}{y}", { minZoom:0, maxZoom: 10 }).addTo(map);
+				expect(spy.called).to.be.ok();
+			});
+		});
+
+		describe("when a new layer with greater zoomlevel coverage than the current layer is added to a map", function () {
+			it("fires a zoomlevelschange event", function () {
+				var spy = sinon.spy();
+				L.tileLayer("{z}{x}{y}", { minZoom:0, maxZoom: 10 }).addTo(map);
+				map.on("zoomlevelschange", spy);
+				expect(spy.called).not.to.be.ok();
+				L.tileLayer("{z}{x}{y}", { minZoom:0, maxZoom: 15 }).addTo(map);
+				expect(spy.called).to.be.ok();
+			});
+		});
+
+		describe("when a new layer with the same or lower zoomlevel coverage as the current layer is added to a map", function () {
+			it("fires no zoomlevelschange event", function () {
+				var spy = sinon.spy();
+				L.tileLayer("{z}{x}{y}", { minZoom:0, maxZoom: 10 }).addTo(map);
+				map.on("zoomlevelschange", spy);
+				expect(spy.called).not.to.be.ok();
+				L.tileLayer("{z}{x}{y}", { minZoom:0, maxZoom: 10 }).addTo(map);
+				expect(spy.called).not.to.be.ok();
+				L.tileLayer("{z}{x}{y}", { minZoom:0, maxZoom: 5 }).addTo(map);
+				expect(spy.called).not.to.be.ok();
+			});
+		});
+	});
+
+	describe("#removeLayer", function () {
+		describe("when the last tile layer on a map is removed", function () {
+			it("fires a zoomlevelschange event", function () {
+				map.whenReady(function(){
+					var spy = sinon.spy();
+					var tl = L.tileLayer("{z}{x}{y}", { minZoom:0, maxZoom: 10 }).addTo(map);
+
+					map.on("zoomlevelschange", spy);
+					expect(spy.called).not.to.be.ok();
+					map.removeLayer(tl);
+					expect(spy.called).to.be.ok();
+				});
+			});
+		});
+
+		describe("when a tile layer is removed from a map and it had greater zoom level coverage than the remainding layer", function () {
+			it("fires a zoomlevelschange event", function () {
+				map.whenReady(function(){
+					var spy = sinon.spy(),
+						tl = L.tileLayer("{z}{x}{y}", { minZoom:0, maxZoom: 10 }).addTo(map),
+					    t2 = L.tileLayer("{z}{x}{y}", { minZoom:0, maxZoom: 15 }).addTo(map);
+
+					map.on("zoomlevelschange", spy);
+					expect(spy.called).to.not.be.ok();
+					map.removeLayer(t2);
+					expect(spy.called).to.be.ok();
+				});
+			});
+		});
+
+		describe("when a tile layer is removed from a map it and it had lesser or the sa,e zoom level coverage as the remainding layer(s)", function () {
+			it("fires no zoomlevelschange event", function () {
+				map.whenReady(function(){
+					var tl = L.tileLayer("{z}{x}{y}", { minZoom:0, maxZoom: 10 }).addTo(map),
+					    t2 = L.tileLayer("{z}{x}{y}", { minZoom:0, maxZoom: 10 }).addTo(map),
+					    t3 = L.tileLayer("{z}{x}{y}", { minZoom:0, maxZoom: 5 }).addTo(map);
+
+					map.on("zoomlevelschange", spy);
+					expect(spy).not.toHaveBeenCalled();
+					map.removeLayer(t2);
+					expect(spy).not.toHaveBeenCalled();
+					map.removeLayer(t3);
+					expect(spy).not.toHaveBeenCalled();
+				});
+			});
+		});
+	});
+
+	describe("#eachLayer", function () {
+		it("returns self", function () {
+			expect(map.eachLayer(function () {})).to.be(map);
+		});
+
+		it("calls the provided function for each layer", function () {
+			var t1 = L.tileLayer("{z}{x}{y}").addTo(map),
+			    t2 = L.tileLayer("{z}{x}{y}").addTo(map),
+				spy = sinon.spy();
+
+			map.eachLayer(spy);
+
+			expect(spy.callCount).to.eql(2);
+			expect(spy.firstCall.args).to.eql([t1]);
+			expect(spy.secondCall.args).to.eql([t2]);
+		});
+
+		it("calls the provided function with the provided context", function () {
+			var t1 = L.tileLayer("{z}{x}{y}").addTo(map),
+				spy = sinon.spy();
+
+			map.eachLayer(spy, map);
+
+			expect(spy.thisValues[0]).to.eql(map);
+		});
+	});
+});

data/lib/leaflet/src/Leaflet.js

@@ -0,0 +1,23 @@
+
+var oldL = window.L,
+    L = {};
+
+L.version = '0.6-dev';
+
+// define Leaflet for Node module pattern loaders, including Browserify
+if (typeof module === 'object' && typeof module.exports === 'object') {
+	module.exports = L;
+
+// define Leaflet as an AMD module
+} else if (typeof define === 'function' && define.amd) {
+	define('leaflet', [], function () { return L; });
+}
+
+// define Leaflet as a global L variable, saving the original L to restore later if needed
+
+L.noConflict = function () {
+	window.L = oldL;
+	return this;
+};
+
+window.L = L;

data/lib/leaflet/src/control/Control.Attribution.js

@@ -0,0 +1,115 @@
+/*
+ * L.Control.Attribution is used for displaying attribution on the map (added by default).
+ */
+
+L.Control.Attribution = L.Control.extend({
+	options: {
+		position: 'bottomright',
+		prefix: '<a href="http://leafletjs.com" title="A JS library for interactive maps">Leaflet</a>'
+	},
+
+	initialize: function (options) {
+		L.setOptions(this, options);
+
+		this._attributions = {};
+	},
+
+	onAdd: function (map) {
+		this._container = L.DomUtil.create('div', 'leaflet-control-attribution');
+		L.DomEvent.disableClickPropagation(this._container);
+
+		map
+		    .on('layeradd', this._onLayerAdd, this)
+		    .on('layerremove', this._onLayerRemove, this);
+
+		this._update();
+
+		return this._container;
+	},
+
+	onRemove: function (map) {
+		map
+		    .off('layeradd', this._onLayerAdd)
+		    .off('layerremove', this._onLayerRemove);
+
+	},
+
+	setPrefix: function (prefix) {
+		this.options.prefix = prefix;
+		this._update();
+		return this;
+	},
+
+	addAttribution: function (text) {
+		if (!text) { return; }
+
+		if (!this._attributions[text]) {
+			this._attributions[text] = 0;
+		}
+		this._attributions[text]++;
+
+		this._update();
+
+		return this;
+	},
+
+	removeAttribution: function (text) {
+		if (!text) { return; }
+
+		if (this._attributions[text]) {
+			this._attributions[text]--;
+			this._update();
+		}
+
+		return this;
+	},
+
+	_update: function () {
+		if (!this._map) { return; }
+
+		var attribs = [];
+
+		for (var i in this._attributions) {
+			if (this._attributions[i]) {
+				attribs.push(i);
+			}
+		}
+
+		var prefixAndAttribs = [];
+
+		if (this.options.prefix) {
+			prefixAndAttribs.push(this.options.prefix);
+		}
+		if (attribs.length) {
+			prefixAndAttribs.push(attribs.join(', '));
+		}
+
+		this._container.innerHTML = prefixAndAttribs.join(' | ');
+	},
+
+	_onLayerAdd: function (e) {
+		if (e.layer.getAttribution) {
+			this.addAttribution(e.layer.getAttribution());
+		}
+	},
+
+	_onLayerRemove: function (e) {
+		if (e.layer.getAttribution) {
+			this.removeAttribution(e.layer.getAttribution());
+		}
+	}
+});
+
+L.Map.mergeOptions({
+	attributionControl: true
+});
+
+L.Map.addInitHook(function () {
+	if (this.options.attributionControl) {
+		this.attributionControl = (new L.Control.Attribution()).addTo(this);
+	}
+});
+
+L.control.attribution = function (options) {
+	return new L.Control.Attribution(options);
+};