leaflet-js 0.7.9 → 0.8.dev2

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

@@ -0,0 +1,104 @@
+describe("Point", function () {
+
+	describe('constructor', function () {
+
+		it("creates a point with the given x and y", function () {
+			var p = new L.Point(1.5, 2.5);
+			expect(p.x).to.eql(1.5);
+			expect(p.y).to.eql(2.5);
+		});
+
+		it("rounds the given x and y if the third argument is true", function () {
+			var p = new L.Point(1.3, 2.7, true);
+			expect(p.x).to.eql(1);
+			expect(p.y).to.eql(3);
+		});
+	});
+
+	describe('#subtract', function () {
+		it('subtracts the given point from this one', function () {
+			var a = new L.Point(50, 30),
+				b = new L.Point(20, 10);
+			expect(a.subtract(b)).to.eql(new L.Point(30, 20));
+		});
+	});
+
+	describe('#add', function () {
+		it('adds given point to this one', function () {
+			expect(new L.Point(50, 30).add(new L.Point(20, 10))).to.eql(new L.Point(70, 40));
+		});
+	});
+
+	describe('#divideBy', function () {
+		it('divides this point by the given amount', function () {
+			expect(new L.Point(50, 30).divideBy(5)).to.eql(new L.Point(10, 6));
+		});
+	});
+
+	describe('#multiplyBy', function () {
+		it('multiplies this point by the given amount', function () {
+			expect(new L.Point(50, 30).multiplyBy(2)).to.eql(new L.Point(100, 60));
+		});
+	});
+
+	describe('#floor', function () {
+		it('returns a new point with floored coordinates', function () {
+			expect(new L.Point(50.56, 30.123).floor()).to.eql(new L.Point(50, 30));
+		});
+	});
+
+	describe('#distanceTo', function () {
+		it('calculates distance between two points', function () {
+			var p1 = new L.Point(0, 30);
+			var p2 = new L.Point(40, 0);
+			expect(p1.distanceTo(p2)).to.eql(50.0);
+		});
+	});
+
+	describe('#equals', function () {
+		it('returns true if points are equal', function () {
+			var p1 = new L.Point(20.4, 50.12);
+			var p2 = new L.Point(20.4, 50.12);
+			var p3 = new L.Point(20.5, 50.13);
+
+			expect(p1.equals(p2)).to.be(true);
+			expect(p1.equals(p3)).to.be(false);
+		});
+	});
+
+	describe('#contains', function () {
+		it('returns true if the point is bigger in absolute dimensions than the passed one', function () {
+			var p1 = new L.Point(50, 30),
+				p2 = new L.Point(-40, 20),
+				p3 = new L.Point(60, -20),
+				p4 = new L.Point(-40, -40);
+
+			expect(p1.contains(p2)).to.be(true);
+			expect(p1.contains(p3)).to.be(false);
+			expect(p1.contains(p4)).to.be(false);
+		});
+	});
+
+	describe('#toString', function () {
+		it('formats a string out of point coordinates', function () {
+			expect(new L.Point(50, 30) + '').to.eql('Point(50, 30)');
+		});
+	});
+
+	describe('L.point factory', function () {
+		it('leaves L.Point instances as is', function () {
+			var p = new L.Point(50, 30);
+			expect(L.point(p)).to.be(p);
+		});
+		it('creates a point out of three arguments', function () {
+			expect(L.point(50.1, 30.1, true)).to.eql(new L.Point(50, 30));
+		});
+		it('creates a point from an array of coordinates', function () {
+			expect(L.point([50, 30])).to.eql(new L.Point(50, 30));
+		});
+		it('does not fail on invalid arguments', function () {
+			expect(L.point(undefined)).to.be(undefined);
+			expect(L.point(null)).to.be(null);
+		});
+	});
+});

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

@@ -0,0 +1,27 @@
+describe('PolyUtil', function () {
+
+	describe('#clipPolygon', function () {
+		it('clips polygon by bounds', function () {
+			var bounds = L.bounds([0, 0], [10, 10]);
+
+			var points = [
+				new L.Point(5, 5),
+				new L.Point(15, 10),
+				new L.Point(10, 15)
+			];
+
+			var clipped = L.PolyUtil.clipPolygon(points, bounds);
+
+			for (var i = 0, len = clipped.length; i < len; i++) {
+				delete clipped[i]._code;
+			}
+
+			expect(clipped).to.eql([
+				new L.Point(8, 10),
+				new L.Point(5, 5),
+				new L.Point(10, 8),
+				new L.Point(10, 10)
+			]);
+		});
+	});
+});

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,86 @@
+describe('FeatureGroup', function () {
+	var map;
+	beforeEach(function () {
+		map = L.map(document.createElement('div'));
+		map.setView([0, 0], 1);
+	});
+	describe("#_propagateEvent", function () {
+		var marker;
+		beforeEach(function () {
+			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 wasClicked1,
+					wasClicked2;
+
+				fg2.on('click', function (e) {
+					expect(e.layer).to.be(marker);
+					expect(e.target).to.be(fg2);
+					wasClicked2 = true;
+				});
+
+				fg1.on('click', function (e) {
+					expect(e.layer).to.be(marker);
+					expect(e.target).to.be(fg1);
+					wasClicked1 = true;
+				});
+
+				marker.fire('click', {type: 'click'}, true);
+
+				expect(wasClicked1).to.be(true);
+				expect(wasClicked2).to.be(true);
+			});
+		});
+	});
+	describe('addLayer', function () {
+		it('adds the layer', function () {
+			var fg = L.featureGroup(),
+			    marker = L.marker([0, 0]);
+
+			expect(fg.hasLayer(marker)).to.be(false);
+
+			fg.addLayer(marker);
+
+			expect(fg.hasLayer(marker)).to.be(true);
+		});
+		it('supports non-evented layers', function () {
+			var fg = L.featureGroup(),
+			    g = L.layerGroup();
+
+			expect(fg.hasLayer(g)).to.be(false);
+
+			fg.addLayer(g);
+
+			expect(fg.hasLayer(g)).to.be(true);
+		});
+	});
+	describe('removeLayer', function () {
+		it('removes the layer passed to it', function () {
+			var fg = L.featureGroup(),
+			    marker = L.marker([0, 0]);
+
+			fg.addLayer(marker);
+			expect(fg.hasLayer(marker)).to.be(true);
+
+			fg.removeLayer(marker);
+			expect(fg.hasLayer(marker)).to.be(false);
+		});
+		it('removes the layer passed to it by id', function () {
+			var fg = L.featureGroup(),
+			    marker = L.marker([0, 0]);
+
+			fg.addLayer(marker);
+			expect(fg.hasLayer(marker)).to.be(true);
+
+			fg.removeLayer(L.stamp(marker));
+			expect(fg.hasLayer(marker)).to.be(false);
+		});
+	});
+});

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

@@ -0,0 +1,282 @@
+describe("L.GeoJSON", function () {
+	describe("addData", function () {
+		var geoJSON = {
+			type: 'Feature',
+			properties: {},
+			geometry: {
+				type: 'Point',
+				coordinates: [20, 10, 5]
+			}
+		};
+
+		it("sets feature property on member layers", function () {
+			var layer = new L.GeoJSON();
+			layer.addData(geoJSON);
+			expect(layer.getLayers()[0].feature).to.eql(geoJSON);
+		});
+
+		it("normalizes a geometry to a Feature", function () {
+			var layer = new L.GeoJSON();
+			layer.addData(geoJSON.geometry);
+			expect(layer.getLayers()[0].feature).to.eql(geoJSON);
+		});
+	});
+});
+
+describe("L.Marker#toGeoJSON", function () {
+	it("returns a 2D Point object", function () {
+		var marker = new L.Marker([10, 20]);
+		expect(marker.toGeoJSON().geometry).to.eql({
+			type: 'Point',
+			coordinates: [20, 10]
+		});
+	});
+
+	it("returns a 3D Point object", function () {
+		var marker = new L.Marker([10, 20, 30]);
+		expect(marker.toGeoJSON().geometry).to.eql({
+			type: 'Point',
+			coordinates: [20, 10, 30]
+		});
+	});
+});
+
+describe("L.Circle#toGeoJSON", function () {
+	it("returns a 2D Point object", function () {
+		var circle = new L.Circle([10, 20], 100);
+		expect(circle.toGeoJSON().geometry).to.eql({
+			type: 'Point',
+			coordinates: [20, 10]
+		});
+	});
+
+	it("returns a 3D Point object", function () {
+		var circle = new L.Circle([10, 20, 30], 100);
+		expect(circle.toGeoJSON().geometry).to.eql({
+			type: 'Point',
+			coordinates: [20, 10, 30]
+		});
+	});
+});
+
+describe("L.CircleMarker#toGeoJSON", function () {
+	it("returns a 2D Point object", function () {
+		var marker = new L.CircleMarker([10, 20]);
+		expect(marker.toGeoJSON().geometry).to.eql({
+			type: 'Point',
+			coordinates: [20, 10]
+		});
+	});
+
+	it("returns a 3D Point object", function () {
+		var marker = new L.CircleMarker([10, 20, 30]);
+		expect(marker.toGeoJSON().geometry).to.eql({
+			type: 'Point',
+			coordinates: [20, 10, 30]
+		});
+	});
+});
+
+describe("L.Polyline#toGeoJSON", function () {
+	it("returns a 2D LineString object", function () {
+		var polyline = new L.Polyline([[10, 20], [2, 5]]);
+		expect(polyline.toGeoJSON().geometry).to.eql({
+			type: 'LineString',
+			coordinates: [[20, 10], [5, 2]]
+		});
+	});
+
+	it("returns a 3D LineString object", function () {
+		var polyline = new L.Polyline([[10, 20, 30], [2, 5, 10]]);
+		expect(polyline.toGeoJSON().geometry).to.eql({
+			type: 'LineString',
+			coordinates: [[20, 10, 30], [5, 2, 10]]
+		});
+	});
+});
+
+describe("L.Polyline (multi) #toGeoJSON", function () {
+	it("returns a 2D MultiLineString object", function () {
+		var multiPolyline = new L.Polyline([[[10, 20], [2, 5]], [[1, 2], [3, 4]]]);
+		expect(multiPolyline.toGeoJSON().geometry).to.eql({
+			type: 'MultiLineString',
+			coordinates: [
+				[[20, 10], [5, 2]],
+				[[2, 1], [4, 3]]
+			]
+		});
+	});
+
+	it("returns a 3D MultiLineString object", function () {
+		var multiPolyline = new L.Polyline([[[10, 20, 30], [2, 5, 10]], [[1, 2, 3], [4, 5, 6]]]);
+		expect(multiPolyline.toGeoJSON().geometry).to.eql({
+			type: 'MultiLineString',
+			coordinates: [
+				[[20, 10, 30], [5, 2, 10]],
+				[[2, 1, 3], [5, 4, 6]]
+			]
+		});
+	});
+});
+
+describe("L.Polygon#toGeoJSON", function () {
+	it("returns a 2D Polygon object (no holes)", function () {
+		var polygon = new L.Polygon([[1, 2], [3, 4], [5, 6]]);
+		expect(polygon.toGeoJSON().geometry).to.eql({
+			type: 'Polygon',
+			coordinates: [[[2, 1], [4, 3], [6, 5], [2, 1]]]
+		});
+	});
+
+	it("returns a 3D Polygon object (no holes)", function () {
+		var polygon = new L.Polygon([[1, 2, 3], [4, 5, 6], [7, 8, 9]]);
+		expect(polygon.toGeoJSON().geometry).to.eql({
+			type: 'Polygon',
+			coordinates: [[[2, 1, 3], [5, 4, 6], [8, 7, 9], [2, 1, 3]]]
+		});
+	});
+
+	it("returns a 2D 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().geometry).to.eql({
+			type: 'Polygon',
+			coordinates: [
+				[[2, 1], [4, 3], [6, 5], [2, 1]],
+				[[8, 7], [10, 9], [12, 11], [8, 7]]
+			]
+		});
+	});
+
+	it("returns a 3D Polygon object (with holes)", function () {
+		var polygon = new L.Polygon([[[1, 2, 3], [4, 5, 6], [7, 8, 9]], [[10, 11, 12], [13, 14, 15], [16, 17, 18]]]);
+		expect(polygon.toGeoJSON().geometry).to.eql({
+			type: 'Polygon',
+			coordinates: [
+				[[2, 1, 3], [5, 4, 6], [8, 7, 9], [2, 1, 3]],
+				[[11, 10, 12], [14, 13, 15], [17, 16, 18], [11, 10, 12]]
+			]
+		});
+	});
+});
+
+describe("L.Polygon (multi) #toGeoJSON", function () {
+	it("returns a 2D MultiPolygon object", function () {
+		var multiPolygon = new L.Polygon([[[1, 2], [3, 4], [5, 6]]]);
+		expect(multiPolygon.toGeoJSON().geometry).to.eql({
+			type: 'MultiPolygon',
+			coordinates: [
+				[[[2, 1], [4, 3], [6, 5], [2, 1]]]
+			]
+		});
+	});
+
+	it("returns a 3D MultiPolygon object", function () {
+		var multiPolygon = new L.Polygon([[[1, 2, 3], [4, 5, 6], [7, 8, 9]]]);
+		expect(multiPolygon.toGeoJSON().geometry).to.eql({
+			type: 'MultiPolygon',
+			coordinates: [
+				[[[2, 1, 3], [5, 4, 6], [8, 7, 9], [2, 1, 3]]]
+			]
+		});
+	});
+});
+
+describe("L.LayerGroup#toGeoJSON", function () {
+	it("returns a 2D FeatureCollection 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: 'FeatureCollection',
+			features: [marker.toGeoJSON(), polyline.toGeoJSON()]
+		});
+	});
+
+	it("returns a 3D FeatureCollection object", function () {
+		var marker = new L.Marker([10, 20, 30]),
+				polyline = new L.Polyline([[10, 20, 30], [2, 5, 10]]),
+				layerGroup = new L.LayerGroup([marker, polyline]);
+		expect(layerGroup.toGeoJSON()).to.eql({
+			type: 'FeatureCollection',
+			features: [marker.toGeoJSON(), polyline.toGeoJSON()]
+		});
+	});
+
+	it("ensures that every member is a Feature", function () {
+		var tileLayer = new L.TileLayer(),
+		    layerGroup = new L.LayerGroup([tileLayer]);
+
+		tileLayer.toGeoJSON = function () {
+			return {
+				type: 'Point',
+				coordinates: [20, 10]
+			};
+		};
+
+		expect(layerGroup.toGeoJSON()).to.eql({
+			type: 'FeatureCollection',
+			features: [{
+				type: 'Feature',
+				properties: {},
+				geometry: {
+					type: 'Point',
+					coordinates: [20, 10]
+				}
+			}]
+		});
+	});
+
+	it('roundtrips GeometryCollection features', function () {
+		var json = {
+			"type": "FeatureCollection",
+			"features": [{
+				"type": "Feature",
+				"geometry": {
+					"type": "GeometryCollection",
+					"geometries": [{
+						"type": "LineString",
+						"coordinates": [[-122.4425587930444, 37.80666418607323], [-122.4428379594768, 37.80663578323093]]
+					}, {
+						"type": "LineString",
+						"coordinates": [
+							[-122.4425509770566, 37.80662588061205],
+							[-122.4428340530617, 37.8065999493009]
+						]
+					}]
+				},
+				"properties": {
+					"name": "SF Marina Harbor Master"
+				}
+			}]
+		};
+
+		expect(L.geoJson(json).toGeoJSON()).to.eql(json);
+	});
+
+	it('roundtrips MiltiPoint features', function () {
+		var json = {
+			"type": "FeatureCollection",
+			"features": [{
+				"type": "Feature",
+				"geometry": {
+					"type": "MultiPoint",
+					"coordinates": [[-122.4425587930444, 37.80666418607323], [-122.4428379594768, 37.80663578323093]]
+				},
+				"properties": {
+					"name": "Test MultiPoints"
+				}
+			}]
+		};
+
+		expect(L.geoJson(json).toGeoJSON()).to.eql(json);
+	});
+
+	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: 'FeatureCollection',
+			features: []
+		});
+	});
+});