leaflet-ruby 0.3.beta1

data/lib/leaflet/spec/suites/dom/DomUtilSpec.js

@@ -0,0 +1,59 @@
+describe('DomUtil', function() {
+	var el;
+	
+	beforeEach(function() {
+		el = document.createElement('div');
+		el.style.position = 'absolute';
+		el.style.top = el.style.left = '-10000px';
+		document.body.appendChild(el);
+	});
+	
+	afterEach(function() {
+		document.body.removeChild(el);
+	});
+	
+	describe('#get', function() {
+		it('should get element by id if the given argument is string', function() {
+			el.id = 'testId';
+			expect(L.DomUtil.get(el.id)).toBe(el);
+		});
+		
+		it('should return the element if it is given as an argument', function() {
+			expect(L.DomUtil.get(el)).toBe(el);
+		});
+	});
+	
+	describe('#addClass, #removeClass, #hasClass', function() {
+		it('should has defined class for test element', function() {
+			el.className = 'bar foo baz ';
+			expect(L.DomUtil.hasClass(el, 'foo')).toBeTruthy();
+			expect(L.DomUtil.hasClass(el, 'bar')).toBeTruthy();
+			expect(L.DomUtil.hasClass(el, 'baz')).toBeTruthy();
+			expect(L.DomUtil.hasClass(el, 'boo')).toBeFalsy();
+		});
+		
+		it('should properly addClass and removeClass for element', function() {
+			el.className = '';
+			L.DomUtil.addClass(el, 'foo');
+			
+			expect(el.className).toEqual('foo');
+			expect(L.DomUtil.hasClass(el, 'foo')).toBeTruthy();
+			
+			L.DomUtil.addClass(el, 'bar');
+			expect(el.className).toEqual('foo bar');
+			expect(L.DomUtil.hasClass(el, 'foo')).toBeTruthy();
+			
+			L.DomUtil.removeClass(el, 'foo');
+			expect(el.className).toEqual('bar');
+			expect(L.DomUtil.hasClass(el, 'foo')).toBeFalsy();
+			
+			el.className = 'foo bar barz';
+			L.DomUtil.removeClass(el, 'bar');
+			expect(el.className).toEqual('foo barz');
+		})
+	});
+	
+	describe('#setPosition', noSpecs);
+	
+	describe('#getStyle', noSpecs);
+});

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

@@ -0,0 +1 @@
+describe('LatLngBounds', noSpecs);

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

@@ -0,0 +1,76 @@
+describe('LatLng', function() {
+	describe('constructor', function() {
+		it("should set lat and lng", function() {
+			var a = new L.LatLng(25, 74);
+			expect(a.lat).toEqual(25);
+			expect(a.lng).toEqual(74);
+	
+			var a = new L.LatLng(-25, -74);
+			expect(a.lat).toEqual(-25);
+			expect(a.lng).toEqual(-74);
+		});
+		
+		it("should clamp latitude to lie between -90 and 90", function() {
+			var a = new L.LatLng(150, 0).lat;
+			expect(a).toEqual(90);
+			
+			var b = new L.LatLng(-230, 0).lat;
+			expect(b).toEqual(-90);
+		});
+		
+		it("should clamp longtitude to lie between -180 and 180", function() {
+			var a = new L.LatLng(0, 190).lng;
+			expect(a).toEqual(-170);
+
+			var b = new L.LatLng(0, 360).lng;
+			expect(b).toEqual(0);
+			
+			var c = new L.LatLng(0, 380).lng;
+			expect(c).toEqual(20);
+	
+			var d = new L.LatLng(0, -190).lng;
+			expect(d).toEqual(170);
+	
+			var e = new L.LatLng(0, -360).lng;
+			expect(e).toEqual(0);
+	
+			var f = new L.LatLng(0, -380).lng;
+			expect(f).toEqual(-20);
+
+			var g = new L.LatLng(0, 90).lng;
+			expect(g).toEqual(90);
+
+			var h = new L.LatLng(0, 180).lng;
+			expect(h).toEqual(180);
+	 });
+		
+		it("should not clamp latitude and longtitude if unbounded flag set to true", function() {
+			var a = new L.LatLng(150, 0, true).lat;
+			expect(a).toEqual(150);
+			
+			var b = new L.LatLng(-230, 0, true).lat;
+			expect(b).toEqual(-230);
+	
+			var c = new L.LatLng(0, 250, true).lng;
+			expect(c).toEqual(250);
+	
+			var d = new L.LatLng(0, -190, true).lng;
+			expect(d).toEqual(-190);
+		});
+	});
+	
+	describe('#equals', function() {
+		it("should return 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)).toBe(true);
+		});
+		
+		it("should return 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)).toBe(false);
+		});
+	});
+});
+

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

@@ -0,0 +1,42 @@
+xdescribe("Projection.Mercator", function() {
+	var p = L.Projection.Mercator;
+	
+	beforeEach(function() {
+		function almostEqual(a, b, p) {
+			return Math.abs(a - b) <= (p || 1.0E-12);
+		};
+		this.addMatchers({
+			toAlmostEqual: function(expected, margin) {
+				var p1 = this.actual,
+					p2 = expected;
+				return almostEqual(p1.x, p2.x, margin) && almostEqual(p1.y, p2.y, margin);
+			}
+		});
+	});
+	
+
+	describe("#project", function() {
+		it("should do projection properly", function() {
+			//edge cases
+			expect(p.project(new L.LatLng(0, 0))).toAlmostEqual(new L.Point(0, 0));
+			expect(p.project(new L.LatLng(90, 180))).toAlmostEqual(new L.Point(-Math.PI, Math.PI));
+			expect(p.project(new L.LatLng(-90, -180))).toAlmostEqual(new L.Point(-Math.PI, -Math.PI));
+			
+			expect(p.project(new L.LatLng(50, 30))).toAlmostEqual(new L.Point(0.523598775598, 1.010683188683));
+		});
+	});
+
+	describe("#unproject", function() {
+		it("should do unprojection properly", function() {
+			function pr(point) {
+				return p.project(p.unproject(point));
+			}
+			
+			expect(pr(new L.Point(0, 0))).toAlmostEqual(new L.Point(0, 0));
+			expect(pr(new L.Point(-Math.PI, Math.PI))).toAlmostEqual(new L.Point(-Math.PI, Math.PI));
+			expect(pr(new L.Point(-Math.PI, -Math.PI))).toAlmostEqual(new L.Point(-Math.PI, -Math.PI));
+			
+			expect(pr(new L.Point(0.523598775598, 1.010683188683))).toAlmostEqual(new L.Point(0.523598775598, 1.010683188683));
+		});
+	});
+});

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

@@ -0,0 +1,53 @@
+describe('Bounds', function() {
+	var a, b;
+	
+	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)
+   		]);
+	});
+	
+	describe('constructor', function() {
+		it('should create bounds with proper min & max on (Point, Point)', function() {
+			expect(a.min).toEqual(new L.Point(14, 12));
+			expect(a.max).toEqual(new L.Point(30, 40));
+		});
+		it('should create bounds with proper min & max on (Point[])', function() {
+			expect(b.min).toEqual(new L.Point(14, 12));
+			expect(b.max).toEqual(new L.Point(30, 40));
+		});
+	});
+	
+	describe('#extend', function() {
+		it('should extend the bounds to contain the given point', function() {
+			a.extend(new L.Point(50, 20));
+			expect(a.min).toEqual(new L.Point(14, 12));
+			expect(a.max).toEqual(new L.Point(50, 40));
+			
+			b.extend(new L.Point(25, 50));
+			expect(b.min).toEqual(new L.Point(14, 12));
+			expect(b.max).toEqual(new L.Point(30, 50));
+		});
+	});
+	
+	describe('#getCenter', function() {
+		it('should return the center point', function() {
+			expect(a.getCenter()).toEqual(new L.Point(22, 26));
+		});
+	});
+    
+	describe('#contains', function() {
+	    it('should contains other bounds or point', function() {
+	        a.extend(new L.Point(50, 10));
+	        expect(a.contains(b)).toBeTruthy();
+	        expect(b.contains(a)).toBeFalsy();
+	        expect(a.contains(new L.Point(24, 25))).toBeTruthy();
+	        expect(a.contains(new L.Point(54, 65))).toBeFalsy();
+	    });
+	});
+});

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

@@ -0,0 +1,45 @@
+describe("Point", function() {
+	
+	describe('constructor', function() {
+		
+		it("should create a point with the given x and y", function() {
+			var p = new L.Point(1.5, 2.5);
+			expect(p.x).toEqual(1.5);
+			expect(p.y).toEqual(2.5);
+		});
+		
+		it("should round 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).toEqual(1);
+			expect(p.y).toEqual(3);
+		});
+	});
+	
+	describe('#subtract', function() {
+		it('should subtract the given point from this one', function() {
+			var a = new L.Point(50, 30),
+				b = new L.Point(20, 10);
+			expect(a.subtract(b)).toEqual(new L.Point(30, 20));
+		});
+	});
+	
+	describe('#add', function() {
+		it('should add the given point to this one', function() {
+			expect(new L.Point(50, 30).add(new L.Point(20, 10))).toEqual(new L.Point(70, 40));
+		});
+	});
+	
+	describe('#divideBy', function() {
+		it('should divide this point by the given amount', function() {
+			expect(new L.Point(50, 30).divideBy(5)).toEqual(new L.Point(10, 6));
+		});
+	});
+	
+	describe('#multiplyBy', function() {
+		it('should multiply this point by the given amount', function() {
+			expect(new L.Point(50, 30).multiplyBy(2)).toEqual(new L.Point(100, 60));
+		});
+	});
+	
+	describe('#distanceTo', noSpecs);
+});

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

@@ -0,0 +1,19 @@
+describe("Transformation", function() {
+	var t, p;
+	
+	beforeEach(function() {
+		t = new L.Transformation(1, 2, 3, 4);
+		p = new L.Point(10, 20);
+	});
+	
+	it("#transform should perform a transformation", function() {
+		var p2 = t.transform(p, 2);
+		expect(p2).toEqual(new L.Point(24, 128));
+	});
+	
+	it("#untransform should perform a reverse transformation", function() {
+		var p2 = t.transform(p, 2);
+		var p3 = t.untransform(p2, 2);
+		expect(p3).toEqual(p);
+	});
+});

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

@@ -0,0 +1 @@
+describe('TileLayer', noSpecs);

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("should calculate correct 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)).toEqual(null);
+			
+			polyline.setLatLngs(latlngs);
+			var point = polyline.closestLayerPoint(p1);
+			expect(point).not.toEqual(null);
+			expect(point.distance).not.toEqual(Infinity);
+			expect(point.distance).not.toEqual(NaN);
+			
+			var point2 = polyline.closestLayerPoint(p2);
+			
+			expect(point.distance).toBeLessThan(point2.distance);
+		});
+	});
+});

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

@@ -0,0 +1 @@
+describe("Map", noSpecs);

data/lib/leaflet/src/Leaflet.js

@@ -0,0 +1,33 @@
+
+(function (root) {
+	root.L = {
+		VERSION: '0.3',
+
+		ROOT_URL: root.L_ROOT_URL || (function () {
+			var scripts = document.getElementsByTagName('script'),
+				leafletRe = /\/?leaflet[\-\._]?([\w\-\._]*)\.js\??/;
+
+			var i, len, src, matches;
+
+			for (i = 0, len = scripts.length; i < len; i++) {
+				src = scripts[i].src;
+				matches = src.match(leafletRe);
+
+				if (matches) {
+					if (matches[1] === 'include') {
+						return '../../dist/';
+					}
+					return src.replace(leafletRe, '') + '/';
+				}
+			}
+			return '';
+		}()),
+
+		noConflict: function () {
+			root.L = this._originalL;
+			return this;
+		},
+
+		_originalL: root.L
+	};
+}(this));

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

@@ -0,0 +1,66 @@
+L.Control.Attribution = L.Class.extend({
+	initialize: function (prefix) {
+		this._prefix = prefix || 'Powered by <a href="http://leaflet.cloudmade.com">Leaflet</a>';
+		this._attributions = {};
+	},
+	
+	onAdd: function (map) {
+		this._container = L.DomUtil.create('div', 'leaflet-control-attribution');
+		L.DomEvent.disableClickPropagation(this._container);
+		this._map = map;
+		this._update();
+	},
+
+	getPosition: function () {
+		return L.Control.Position.BOTTOM_RIGHT;
+	},
+
+	getContainer: function () {
+		return this._container;
+	},
+
+	setPrefix: function (prefix) {
+		this._prefix = prefix;
+		this._update();
+	},
+
+	addAttribution: function (text) {
+		if (!text) {
+			return;
+		}
+		this._attributions[text] = true;
+		this._update();
+	},
+
+	removeAttribution: function (text) {
+		if (!text) {
+			return;
+		}
+		delete this._attributions[text];
+		this._update();
+	},
+
+	_update: function () {
+		if (!this._map) {
+			return;
+		}
+
+		var attribs = [];
+
+		for (var i in this._attributions) {
+			if (this._attributions.hasOwnProperty(i)) {
+				attribs.push(i);
+			}
+		}
+
+		var prefixAndAttribs = [];
+		if (this._prefix) {
+			prefixAndAttribs.push(this._prefix);
+		}
+		if (attribs.length) {
+			prefixAndAttribs.push(attribs.join(', '));
+		}
+
+		this._container.innerHTML = prefixAndAttribs.join(' &mdash; ');
+	}
+});