leaflet-js 0.6.beta4

data/lib/leaflet/spec/suites/geo/LatLngSpec.js

@@ -0,0 +1,118 @@
+describe('LatLng', function() {
+	describe('constructor', function() {
+		it("sets lat and lng", function() {
+			var a = new L.LatLng(25, 74);
+			expect(a.lat).to.eql(25);
+			expect(a.lng).to.eql(74);
+
+			var b = new L.LatLng(-25, -74);
+			expect(b.lat).to.eql(-25);
+			expect(b.lng).to.eql(-74);
+		});
+
+		it('throws an error if invalid lat or lng', function () {
+			expect(function () {
+				var a = new L.LatLng(NaN, NaN);
+			}).to.throwError();
+		});
+	});
+
+	describe('#equals', function() {
+		it("returns true if compared objects are equal within a certain margin", function() {
+			var a = new L.LatLng(10, 20);
+			var b = new L.LatLng(10 + 1.0E-10, 20 - 1.0E-10);
+			expect(a.equals(b)).to.eql(true);
+		});
+
+		it("returns false if compared objects are not equal within a certain margin", function() {
+			var a = new L.LatLng(10, 20);
+			var b = new L.LatLng(10, 23.3);
+			expect(a.equals(b)).to.eql(false);
+		});
+
+		it('returns false if passed non-valid object', function () {
+			var a = new L.LatLng(10, 20);
+			expect(a.equals(null)).to.eql(false);
+		});
+	});
+
+	describe('#wrap', function () {
+		it("wraps longitude to lie between -180 and 180 by default", function() {
+			var a = new L.LatLng(0, 190).wrap().lng;
+			expect(a).to.eql(-170);
+
+			var b = new L.LatLng(0, 360).wrap().lng;
+			expect(b).to.eql(0);
+
+			var c = new L.LatLng(0, 380).wrap().lng;
+			expect(c).to.eql(20);
+
+			var d = new L.LatLng(0, -190).wrap().lng;
+			expect(d).to.eql(170);
+
+			var e = new L.LatLng(0, -360).wrap().lng;
+			expect(e).to.eql(0);
+
+			var f = new L.LatLng(0, -380).wrap().lng;
+			expect(f).to.eql(-20);
+
+			var g = new L.LatLng(0, 90).wrap().lng;
+			expect(g).to.eql(90);
+
+			var h = new L.LatLng(0, 180).wrap().lng;
+			expect(h).to.eql(180);
+		});
+
+		it("wraps longitude within the given range", function() {
+			var a = new L.LatLng(0, 190).wrap(-100, 100).lng;
+			expect(a).to.eql(-10);
+		});
+
+	});
+
+	describe('#toString', function () {
+		it('formats a string', function () {
+			var a = new L.LatLng(10.333333333, 20.2222222);
+			expect(a.toString(3)).to.eql('LatLng(10.333, 20.222)');
+		});
+	});
+
+	describe('#distanceTo', function () {
+		it('calculates distance in meters', function () {
+			var a = new L.LatLng(50.5, 30.5);
+			var b = new L.LatLng(50, 1);
+
+			expect(Math.abs(Math.round(a.distanceTo(b) / 1000) - 2084) < 5).to.eql(true);
+		});
+	});
+
+	describe('L.latLng factory', function () {
+		it('returns LatLng instance as is', function () {
+			var a = new L.LatLng(50, 30);
+
+			expect(L.latLng(a)).to.eql(a);
+		});
+
+		it('accepts an array of coordinates', function () {
+			expect(L.latLng([50, 30])).to.eql(new L.LatLng(50, 30));
+		});
+
+		it('passes null or undefined as is', function () {
+			expect(L.latLng(undefined)).to.eql(undefined);
+			expect(L.latLng(null)).to.eql(null);
+		});
+
+		it('creates a LatLng object from two coordinates', function () {
+			expect(L.latLng(50, 30)).to.eql(new L.LatLng(50, 30));
+		});
+
+		it('accepts an object with lat/lng', function () {
+			expect(L.latLng({lat: 50, lng: 30})).to.eql(new L.LatLng(50, 30));
+		});
+
+		it('accepts an object with lat/lon', function () {
+			expect(L.latLng({lat: 50, lon: 30})).to.eql(new L.LatLng(50, 30));
+		});
+	});
+});
+

data/lib/leaflet/spec/suites/geo/ProjectionSpec.js

@@ -0,0 +1,47 @@
+describe("Projection.Mercator", function() {
+	var p = L.Projection.Mercator;
+
+	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);
+	};
+
+	describe("#project", function() {
+		it("projects a center point", function() {
+			//edge cases
+			expect(p.project(new L.LatLng(0, 0))).near(new L.Point(0, 0));
+		});
+
+		it("projects the northeast corner of the world", function() {
+			expect(p.project(new L.LatLng(90, 180))).near(new L.Point(20037508.342789244, 19970326.50745906));
+		});
+
+		it("projects the southwest corner of the world", function() {
+			expect(p.project(new L.LatLng(-90, -180))).near(new L.Point(-20037508, -19970326));
+		});
+
+		it("projects 50, 30", function() {
+			 expect(p.project(new L.LatLng(50, 30))).near(new L.Point(3339584, 6392021));
+		});
+	});
+
+	describe("#unproject", function() {
+		function pr(point) {
+			return p.project(p.unproject(point));
+		}
+
+		it("unprojects a center point", function() {
+			expect(pr(new L.Point(0, 0))).near(new L.Point(0, 0));
+		});
+
+		it("pi points", function() {
+			expect(pr(new L.Point(-Math.PI, Math.PI))).near(new L.Point(-Math.PI, Math.PI));
+			expect(pr(new L.Point(-Math.PI, -Math.PI))).near(new L.Point(-Math.PI, -Math.PI));
+
+			expect(pr(new L.Point(0.523598775598, 1.010683188683))).near(new L.Point(0.523598775598, 1.010683188683));
+		});
+	});
+});

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

@@ -0,0 +1,87 @@
+describe('Bounds', function() {
+	var a, b, c;
+
+	beforeEach(function() {
+		a = new L.Bounds(
+			new L.Point(14, 12),
+			new L.Point(30, 40));
+		b = new L.Bounds([
+			new L.Point(20, 12),
+			new L.Point(14, 20),
+			new L.Point(30, 40)
+		]);
+		c = new L.Bounds();
+	});
+
+	describe('constructor', function() {
+		it('creates bounds with proper min & max on (Point, Point)', function() {
+			expect(a.min).to.eql(new L.Point(14, 12));
+			expect(a.max).to.eql(new L.Point(30, 40));
+		});
+		it('creates bounds with proper min & max on (Point[])', function() {
+			expect(b.min).to.eql(new L.Point(14, 12));
+			expect(b.max).to.eql(new L.Point(30, 40));
+		});
+	});
+
+	describe('#extend', function() {
+		it('extends the bounds to contain the given point', function() {
+			a.extend(new L.Point(50, 20));
+			expect(a.min).to.eql(new L.Point(14, 12));
+			expect(a.max).to.eql(new L.Point(50, 40));
+
+			b.extend(new L.Point(25, 50));
+			expect(b.min).to.eql(new L.Point(14, 12));
+			expect(b.max).to.eql(new L.Point(30, 50));
+		});
+	});
+
+	describe('#getCenter', function() {
+		it('returns the center point', function() {
+			expect(a.getCenter()).to.eql(new L.Point(22, 26));
+		});
+	});
+
+	describe('#contains', function() {
+		it('contains other bounds or point', function() {
+			a.extend(new L.Point(50, 10));
+			expect(a.contains(b)).to.be.ok();
+			expect(b.contains(a)).to.not.be.ok();
+			expect(a.contains(new L.Point(24, 25))).to.be.ok();
+			expect(a.contains(new L.Point(54, 65))).to.not.be.ok();
+		});
+	});
+
+	describe('#isValid', function() {
+		it('returns true if properly set up', function() {
+			expect(a.isValid()).to.be.ok();
+		});
+		it('returns false if is invalid', function() {
+			expect(c.isValid()).to.not.be.ok();
+		});
+		it('returns true if extended', function() {
+			c.extend([0, 0]);
+			expect(c.isValid()).to.be.ok();
+		});
+	});
+
+	describe('#getSize', function () {
+		it('returns the size of the bounds as point', function () {
+			expect(a.getSize()).to.eql(new L.Point(16, 28));
+		});
+	});
+
+	describe('#intersects', function () {
+		it('returns true if bounds intersect', function () {
+			expect(a.intersects(b)).to.be(true);
+			expect(a.intersects(new L.Bounds(new L.Point(100, 100), new L.Point(120, 120)))).to.eql(false);
+		});
+	});
+
+	describe('L.bounds factory', function () {
+		it('creates bounds from array of number arrays', function () {
+			var bounds = L.bounds([[14, 12], [30, 40]]);
+			expect(bounds).to.eql(a);
+		});
+	});
+});

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

@@ -0,0 +1,75 @@
+describe('LineUtil', function () {
+
+	describe('#clipSegment', function () {
+
+		var bounds;
+
+		beforeEach(function () {
+			bounds = L.bounds([5, 0], [15, 10]);
+		});
+
+		it('clips a segment by bounds', function () {
+			var a = new L.Point(0, 0);
+			var b = new L.Point(15, 15);
+
+			var segment = L.LineUtil.clipSegment(a, b, bounds);
+
+			expect(segment[0]).to.eql(new L.Point(5, 5));
+			expect(segment[1]).to.eql(new L.Point(10, 10));
+
+			var c = new L.Point(5, -5);
+			var d = new L.Point(20, 10);
+
+			var segment2 = L.LineUtil.clipSegment(c, d, bounds);
+
+			expect(segment2[0]).to.eql(new L.Point(10, 0));
+			expect(segment2[1]).to.eql(new L.Point(15, 5));
+		});
+
+		it('uses last bit code and reject segments out of bounds', function () {
+			var a = new L.Point(15, 15);
+			var b = new L.Point(25, 20);
+			var segment = L.LineUtil.clipSegment(a, b, bounds, true);
+
+			expect(segment).to.be(false);
+		});
+	});
+
+	describe('#pointToSegmentDistance & #closestPointOnSegment', function () {
+
+		var p1 = new L.Point(0, 10);
+		var p2 = new L.Point(10, 0);
+		var p = new L.Point(0, 0);
+
+		it('calculates distance from point to segment', function () {
+			expect(L.LineUtil.pointToSegmentDistance(p, p1, p2)).to.eql(Math.sqrt(200) / 2);
+		});
+
+		it('calculates point closest to segment', function () {
+			expect(L.LineUtil.closestPointOnSegment(p, p1, p2)).to.eql(new L.Point(5, 5));
+		});
+	});
+
+	describe('#simplify', function () {
+		it('simplifies polylines according to tolerance', function () {
+			var points = [
+				new L.Point(0, 0),
+				new L.Point(0.01, 0),
+				new L.Point(0.5, 0.01),
+				new L.Point(0.7, 0),
+				new L.Point(1, 0),
+				new L.Point(1.999, 0.999),
+				new L.Point(2, 1)
+			];
+
+			var simplified = L.LineUtil.simplify(points, 0.1);
+
+			expect(simplified).to.eql([
+				new L.Point(0, 0),
+				new L.Point(1, 0),
+				new L.Point(2, 1)
+			]);
+		});
+	});
+
+});

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(7.5, 10),
+				new L.Point(5, 5),
+				new L.Point(10, 7.5),
+				new L.Point(10, 10)
+			]);
+		});
+	});
+});