leaflet-js 0.6.beta4

data/lib/leaflet/spec/suites/geometry/TransformationSpec.js

@@ -0,0 +1,31 @@
+describe("Transformation", function() {
+	var t, p;
+
+	beforeEach(function() {
+		t = new L.Transformation(1, 2, 3, 4);
+		p = new L.Point(10, 20);
+	});
+
+	describe('#transform', function () {
+		it("performs a transformation", function() {
+			var p2 = t.transform(p, 2);
+			expect(p2).to.eql(new L.Point(24, 128));
+		});
+		it('assumes a scale of 1 if not specified', function () {
+			var p2 = t.transform(p);
+			expect(p2).to.eql(new L.Point(12, 64));
+		});
+	});
+
+	describe('#untransform', function () {
+		it("performs a reverse transformation", function() {
+			var p2 = t.transform(p, 2);
+			var p3 = t.untransform(p2, 2);
+			expect(p3).to.eql(p);
+		});
+		it('assumes a scale of 1 if not specified', function () {
+			var p2 = t.transform(p);
+			expect(t.untransform(new L.Point(12, 64))).to.eql(new L.Point(10, 20));
+		});
+	});
+});

data/lib/leaflet/spec/suites/layer/FeatureGroupSpec.js

@@ -0,0 +1,36 @@
+describe('CircleMarker', function () {
+	describe("#_propagateEvent", function () {
+		var map, marker;
+		beforeEach(function () {
+			map = L.map(document.createElement('div'));
+			map.setView([0, 0], 1);
+			marker = L.marker([0, 0]);
+		});
+		describe("when a Marker is added to multiple FeatureGroups ", function () {
+			it("e.layer should be the Marker", function () {
+				var fg1 = L.featureGroup(),
+				    fg2 = L.featureGroup();
+
+				fg1.addLayer(marker);
+				fg2.addLayer(marker);
+
+				var wasClicked = 0;
+				fg2.on('click', function(e) {
+					expect(e.layer).to.be(marker);
+					expect(e.target).to.be(fg2);
+					wasClicked |= 1;
+				});
+
+				fg1.on('click', function (e) {
+					expect(e.layer).to.be(marker);
+					expect(e.target).to.be(fg1);
+					wasClicked |= 2;
+				});
+
+				marker.fire('click', { type: 'click' });
+
+				expect(wasClicked).to.be(3);
+			});
+		});
+	});
+});

data/lib/leaflet/spec/suites/layer/GeoJSONSpec.js

@@ -0,0 +1,86 @@
+describe("L.Marker#toGeoJSON", function () {
+	it("returns a Point object", function () {
+		var marker = new L.Marker([10, 20]);
+		expect(marker.toGeoJSON()).to.eql({
+			type: 'Point',
+			coordinates: [20, 10]
+		});
+	});
+});
+
+describe("L.Polyline#toGeoJSON", function () {
+	it("returns a LineString object", function () {
+		var polyline = new L.Polyline([[10, 20], [2, 5]]);
+		expect(polyline.toGeoJSON()).to.eql({
+			type: 'LineString',
+			coordinates: [[20, 10], [5, 2]]
+		});
+	});
+});
+
+describe("L.MultiPolyline#toGeoJSON", function () {
+	it("returns a MultiLineString object", function () {
+		var multiPolyline = new L.MultiPolyline([[[10, 20], [2, 5]], [[1, 2], [3, 4]]]);
+		expect(multiPolyline.toGeoJSON()).to.eql({
+			type: 'MultiLineString',
+			coordinates: [
+				[[20, 10], [5, 2]],
+				[[2, 1], [4, 3]]
+			]
+		});
+	});
+});
+
+describe("L.Polygon#toGeoJSON", function () {
+	it("returns a Polygon object (no holes)", function () {
+		var polygon = new L.Polygon([[1, 2], [3, 4], [5, 6]]);
+		expect(polygon.toGeoJSON()).to.eql({
+			type: 'Polygon',
+			coordinates: [[[2, 1], [4, 3], [6, 5], [2, 1]]]
+		});
+	});
+
+	it("returns a Polygon object (with holes)", function () {
+		var polygon = new L.Polygon([[[1, 2], [3, 4], [5, 6]], [[7, 8], [9, 10], [11, 12]]]);
+		expect(polygon.toGeoJSON()).to.eql({
+			type: 'Polygon',
+			coordinates: [
+				[[2, 1], [4, 3], [6, 5], [2, 1]],
+				[[8, 7], [10, 9], [12, 11], [8, 7]]
+			]
+		});
+	});
+});
+
+describe("L.MultiPolygon#toGeoJSON", function () {
+	it("returns a MultiPolygon object", function () {
+		var multiPolygon = new L.MultiPolygon([[[1, 2], [3, 4], [5, 6]]]);
+		expect(multiPolygon.toGeoJSON()).to.eql({
+			type: 'MultiPolygon',
+			coordinates: [
+				[[[2, 1], [4, 3], [6, 5], [2, 1]]]
+			]
+		});
+	});
+});
+
+describe("L.LayerGroup#toGeoJSON", function () {
+	it("returns a GeometryCollection object", function () {
+		var marker = new L.Marker([10, 20]),
+		    polyline = new L.Polyline([[10, 20], [2, 5]]),
+		    layerGroup = new L.LayerGroup([marker, polyline]);
+		expect(layerGroup.toGeoJSON()).to.eql({
+			type: 'GeometryCollection',
+			geometries: [marker.toGeoJSON(), polyline.toGeoJSON()]
+		});
+	});
+
+	it("omits layers which do not implement toGeoJSON", function () {
+		var tileLayer = new L.TileLayer(),
+		    layerGroup = new L.LayerGroup([tileLayer]);
+		expect(layerGroup.toGeoJSON()).to.eql({
+			type: 'GeometryCollection',
+			geometries: []
+		});
+	});
+});

data/lib/leaflet/spec/suites/layer/LayerGroupSpec.js

@@ -0,0 +1,58 @@
+describe('LayerGroup', function () {
+	describe("#addLayer", function () {
+		it('adds a layer', function() {
+			var lg = L.layerGroup(),
+				marker = L.marker([0, 0]);
+
+			expect(lg.addLayer(marker)).to.eql(lg);
+
+			expect(lg.hasLayer(marker)).to.be(true);
+		});
+	});
+	describe("#removeLayer", function () {
+		it('removes a layer', function() {
+			var lg = L.layerGroup(),
+				marker = L.marker([0, 0]);
+
+			lg.addLayer(marker);
+			expect(lg.removeLayer(marker)).to.eql(lg);
+
+			expect(lg.hasLayer(marker)).to.be(false);
+		});
+	});
+	describe("#clearLayers", function () {
+		it('removes all layers', function() {
+			var lg = L.layerGroup(),
+				marker = L.marker([0, 0]);
+
+			lg.addLayer(marker);
+			expect(lg.clearLayers()).to.eql(lg);
+
+			expect(lg.hasLayer(marker)).to.be(false);
+		});
+	});
+	describe("#getLayers", function () {
+		it('gets all layers', function() {
+			var lg = L.layerGroup(),
+				marker = L.marker([0, 0]);
+
+			lg.addLayer(marker);
+
+			expect(lg.getLayers()).to.eql([marker]);
+		});
+	});
+	describe("#eachLayer", function () {
+		it('iterates over all layers', function() {
+			var lg = L.layerGroup(),
+				marker = L.marker([0, 0]),
+				ctx = { foo: 'bar' };
+
+			lg.addLayer(marker);
+
+			lg.eachLayer(function(layer) {
+				expect(layer).to.eql(marker);
+				expect(this).to.eql(ctx);
+			}, ctx);
+		});
+	});
+});

data/lib/leaflet/spec/suites/layer/PopupSpec.js

@@ -0,0 +1,59 @@
+describe('Popup', function() {
+
+	var map;
+
+	beforeEach(function () {
+		var c = document.createElement('div');
+		c.style.width = '400px';
+		c.style.height = '400px';
+		map = new L.Map(c);
+		map.setView(new L.LatLng(55.8, 37.6), 6);
+	});
+
+	it("should trigger popupopen on marker when popup opens", function() {
+		var marker1 = new L.Marker(new L.LatLng(55.8, 37.6));
+		var marker2 = new L.Marker(new L.LatLng(57.123076977278, 44.861962891635));
+
+		map.addLayer(marker1);
+		map.addLayer(marker2);
+
+		marker1.bindPopup('Popup1');
+		marker2.bindPopup('Popup2');
+
+		var spy = sinon.spy();
+
+		marker1.on('popupopen', spy);
+
+		expect(spy.called).to.be(false);
+		marker2.openPopup();
+		expect(spy.called).to.be(false);
+		marker1.openPopup();
+		expect(spy.called).to.be(true);
+	});
+
+	it("should trigger popupclose on marker when popup closes", function() {
+		var marker1 = new L.Marker(new L.LatLng(55.8, 37.6));
+		var marker2 = new L.Marker(new L.LatLng(57.123076977278, 44.861962891635));
+
+		map.addLayer(marker1);
+		map.addLayer(marker2);
+
+		marker1.bindPopup('Popup1');
+		marker2.bindPopup('Popup2');
+
+		var spy = sinon.spy();
+
+		marker1.on('popupclose', spy);
+
+		expect(spy.called).to.be(false);
+		marker2.openPopup();
+		expect(spy.called).to.be(false);
+		marker1.openPopup();
+		expect(spy.called).to.be(false);
+		marker2.openPopup();
+		expect(spy.called).to.be(true);
+		marker1.openPopup();
+		marker1.closePopup();
+		expect(spy.callCount).to.be(2);
+	});
+});

data/lib/leaflet/spec/suites/layer/TileLayerSpec.js

@@ -0,0 +1,87 @@
+
+describe('TileLayer', function () {
+	var tileUrl = '';
+
+	describe("#getMaxZoom, #getMinZoom", function () {
+		var map;
+		beforeEach(function () {
+			map = L.map(document.createElement('div'));
+		});
+		describe("when a tilelayer is added to a map with no other layers", function () {
+			it("has the same zoomlevels as the tilelayer", function () {
+				var maxZoom = 10,
+					minZoom = 5;
+					map.setView([0, 0], 1);
+
+					L.tileLayer(tileUrl, {
+						maxZoom: maxZoom,
+						minZoom: minZoom
+					}).addTo(map);
+				expect(map.getMaxZoom()).to.be(maxZoom);
+				expect(map.getMinZoom()).to.be(minZoom);
+			});
+		});
+
+		describe("accessing a tilelayer's properties", function () {
+			it('provides a container', function () {
+				map.setView([0, 0], 1);
+
+				var layer = L.tileLayer(tileUrl).addTo(map);
+				expect(layer.getContainer()).to.be.ok();
+			});
+		});
+
+		describe("when a tilelayer is added to a map that already has a tilelayer", function () {
+			it("has its zoomlevels updated to fit the new layer", function () {
+				map.setView([0, 0], 1);
+
+				L.tileLayer(tileUrl, { minZoom:10, maxZoom: 15 }).addTo(map);
+				expect(map.getMinZoom()).to.be(10);
+				expect(map.getMaxZoom()).to.be(15);
+
+				L.tileLayer(tileUrl, { minZoom:5, maxZoom: 10 }).addTo(map);
+				expect(map.getMinZoom()).to.be(5);  // changed
+				expect(map.getMaxZoom()).to.be(15); // unchanged
+
+
+				L.tileLayer(tileUrl,{ minZoom:10, maxZoom: 20 }).addTo(map);
+				expect(map.getMinZoom()).to.be(5);  // unchanged
+				expect(map.getMaxZoom()).to.be(20); // changed
+
+
+				L.tileLayer(tileUrl, { minZoom:0, maxZoom: 25 }).addTo(map);
+				expect(map.getMinZoom()).to.be(0); // changed
+				expect(map.getMaxZoom()).to.be(25); // changed
+			});
+		});
+		describe("when a tilelayer is removed from a map", function () {
+			it("has its zoomlevels updated to only fit the layers it currently has", function () {
+				var tiles = [  L.tileLayer(tileUrl, { minZoom:10, maxZoom: 15 }).addTo(map),
+							   L.tileLayer(tileUrl, { minZoom:5, maxZoom: 10 }).addTo(map),
+							   L.tileLayer(tileUrl, { minZoom:10, maxZoom: 20 }).addTo(map),
+							   L.tileLayer(tileUrl, { minZoom:0, maxZoom: 25 }).addTo(map)
+							];
+				map.whenReady(function() {
+					expect(map.getMinZoom()).to.be(0);
+					expect(map.getMaxZoom()).to.be(25);
+
+					map.removeLayer(tiles[0]);
+					expect(map.getMinZoom()).to.be(0);
+					expect(map.getMaxZoom()).to.be(25);
+
+					map.removeLayer(tiles[3]);
+					expect(map.getMinZoom()).to.be(5);
+					expect(map.getMaxZoom()).to.be(20);
+
+					map.removeLayer(tiles[2]);
+					expect(map.getMinZoom()).to.be(5);
+					expect(map.getMaxZoom()).to.be(10);
+
+					map.removeLayer(tiles[1]);
+					expect(map.getMinZoom()).to.be(0);
+					expect(map.getMaxZoom()).to.be(Infinity);
+				});
+			});
+		});
+	});
+});

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

@@ -0,0 +1,53 @@
+describe('CircleMarker', function() {
+	describe("#_radius", function() {
+		var map;
+		beforeEach(function() {
+			map = L.map(document.createElement('div'));
+			map.setView([0, 0], 1);
+		});
+		describe("when a CircleMarker is added to the map ", function() {
+			describe("with a radius set as an option", function() {
+				it("takes that radius", function() {
+					var marker = L.circleMarker([0, 0], { radius: 20 }).addTo(map);
+
+					expect(marker._radius).to.be(20);
+				});
+			});
+
+			describe("and radius is set before adding it", function () {
+				it("takes that radius", function () {
+					var marker = L.circleMarker([0, 0], { radius: 20 });
+					marker.setRadius(15);
+					marker.addTo(map);
+					expect(marker._radius).to.be(15);
+				});
+			});
+
+			describe("and radius is set after adding it", function () {
+				it("takes that radius", function () {
+					var marker = L.circleMarker([0, 0], { radius: 20 });
+					marker.addTo(map);
+					marker.setRadius(15);
+					expect(marker._radius).to.be(15);
+				});
+			});
+
+			describe("and setStyle is used to change the radius after adding", function () {
+				it("takes the given radius", function() {
+					var marker = L.circleMarker([0, 0], { radius: 20 });
+					marker.addTo(map);
+					marker.setStyle({ radius: 15 });
+					expect(marker._radius).to.be(15);
+				});
+			});
+			describe("and setStyle is used to change the radius before adding", function () {
+				it("takes the given radius", function () {
+					var marker = L.circleMarker([0, 0], { radius: 20 });
+					marker.setStyle({ radius: 15 });
+					marker.addTo(map);
+					expect(marker._radius).to.be(15);
+				});
+			});
+		});
+	});
+});

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

@@ -0,0 +1,17 @@
+describe('Circle', function () {
+	describe('#getBounds', function () {
+
+		var circle;
+
+		beforeEach(function () {
+			circle = L.circle([50, 30], 200);
+		});
+
+		it('returns bounds', function () {
+			var bounds = circle.getBounds();
+
+			expect(bounds.getSouthWest().equals([49.998203369, 29.997204939])).to.be.ok();
+			expect(bounds.getNorthEast().equals([50.001796631, 30.002795061])).to.be.ok();
+		});
+	});
+});

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

@@ -0,0 +1,55 @@
+describe('Polygon', 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 polygon = new L.Polygon(sourceLatLngs);
+
+			expect(sourceLatLngs).to.eql(originalLatLngs);
+			expect(polygon._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 polygon = new L.Polygon(sourceLatLngs);
+
+			polygon.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 polygon = new L.Polygon(latLngs);
+
+			polygon.spliceLatLngs(1, 1, [7, 8]);
+
+			expect(polygon._latlngs).to.eql([L.latLng([1, 2]), L.latLng([7, 8]), L.latLng([5, 6])]);
+		});
+	});
+});