lsd_rails 0.1

data/Packages/mootools-more/Tests/Specs/1.3/Interface/HtmlTable.Sort.js

@@ -0,0 +1,181 @@
+/*
+---
+name: HtmlTable.Sort Tests
+requires: [More/HtmlTable.Sort]
+provides: [HtmlTable.Sort.Tests]
+...
+*/
+describe('HtmlTable.Sort', function(){
+
+  it('should not step on prior this.bind declarations', function () {
+    var table = new HtmlTable();
+    expect(table.bound.headClick).not.toEqual(null);
+  });
+
+	describe('HtmlTable.Parsers', function(){
+
+		var sortedTable = function(type, data){
+			var table = new HtmlTable({
+				sortable: true,
+				headers: ['col'],
+				parsers: type ? [type] : [],
+				rows: data.map(function(item){return [item];})
+			});
+
+			return Array.map(table.sort(0, false).body.rows, function(item){
+				return item.cells[0].get('text') || item.cells[0].getElement('input').get('value');
+			});
+		};
+
+		describe('date', function(){
+
+			it('should sort on date', function(){
+				expect(sortedTable('date', ['2/4/10', '3/4/10', '1/2/08'])).toEqual(['1/2/08', '2/4/10', '3/4/10']);
+			});
+
+			it('should accept multiple date types', function(){
+				expect(sortedTable('date', ['Jan 5 2010', '01/08/2010', '1/2/08'])).toEqual(['1/2/08', 'Jan 5 2010', '01/08/2010']);
+			});
+
+		});
+
+		describe('input-', function(){
+
+			var data = [
+				new Element('input', {type: 'checkobx', checked: false, value: 'd'}),
+				new Element('input', {type: 'checkbox', checked: true, value: 'a'}),
+				new Element('input', {type: 'checkbox', checked: false, value: 'c'}),
+				new Element('input', {type: 'checkbox', checked: true, value: 'b'})
+			];
+
+			describe('input-checked', function(){
+
+				it('should sort by checked inputs', function(){
+					var result = sortedTable('input-checked', data);
+					expect(result[0]).not.toEqual('d');
+					expect(result[0]).not.toEqual('c');
+					expect(result[3]).not.toEqual('b');
+					expect(result[3]).not.toEqual('a');
+				});
+
+			});
+
+			describe('input-value', function(){
+
+				it('should sort by input value', function(){
+					expect(sortedTable('input-value', data)).toEqual(['a', 'b', 'c', 'd']);
+				});
+
+			});
+
+		});
+
+		describe('number', function(){
+
+			it('should sort a list numerically', function(){
+				expect(sortedTable('number', [3, 1, 2])).toEqual(['1', '2', '3']);
+				expect(sortedTable('number', [3, 1, 12, 2])).toEqual(['1', '2', '3', '12']);
+			});
+
+			it('should accept numbers as strings', function(){
+				expect(sortedTable('number', ['3', '1', 2])).toEqual(['1', '2', '3']);
+			});
+
+			it('should not sort floats according to value', function(){
+				expect(sortedTable('number', ['.03', '1', '.2'])).not.toEqual(['.03', '.2', '1']);
+			});
+
+		});
+
+		describe('numberLax', function(){
+
+			it('should sort a alphanumerical list numerically', function(){
+				expect(sortedTable('number', ['12c', '1a', '4b'])).toEqual(['1a', '4b', '12c']);
+			});
+
+		});
+
+		describe('float', function(){
+
+			it('should correctly sort floats according to value', function(){
+				expect(sortedTable('float', ['1', '.03', '.2'])).toEqual(['.03', '.2', '1']);
+			});
+
+			it('should sort by float when autodetecting a mix of floats and integers are present', function(){
+				expect(sortedTable(false, [1.3, 1.2, 1.1, 1, 2])).toEqual(['1', '1.1', '1.2', '1.3', '2']);
+			});
+
+		});
+
+		describe('floatLax', function(){
+
+			it('should correctly sort alpha-floats according to value', function(){
+				expect(sortedTable('float', ['.2b', '1c', '.03a'])).toEqual(['.03a', '.2b', '1c']);
+			});
+
+		});
+
+		describe('string', function(){
+
+			it('should sort a list alphabetically', function(){
+				expect(sortedTable('string', ['a', 'c', 'b'])).toEqual(['a', 'b', 'c']);
+			});
+
+			it('should not be case sensitive', function(){
+				expect(sortedTable('string', ['A', 'C', 'b'])).toEqual(['A', 'b', 'C']);
+			});
+
+			it('should sort a list of numbers alphabetically', function(){
+				expect(sortedTable('string', [1, 2, 3, 12])).toEqual(['1', '12', '2', '3']);
+			});
+
+		});
+
+		describe('title', function(){
+
+			it('should sort a list alphabetically by title', function(){
+				var data = [
+					new Element('div', {title: 'b', text: 'b'}),
+					new Element('div', {title: 'a', text: 'a'}),
+					new Element('div', {title: 'c', text: 'c'})
+				];
+				expect(sortedTable('string', data)).toEqual(['a', 'b', 'c']);
+			});
+
+		});
+
+	});
+
+	describe('serialize/deserialize', function(){
+
+		it('should serialize the sorted state of a table', function(){
+			var table = new HtmlTable({
+				sortable: true,
+				headers: ['col'],
+				parsers: ['number'],
+				rows: [[1],[0],[2]]
+			});
+
+			table.sort(0, false);
+			expect(table.serialize()).toEqual({sortIndex: 0, sortReverse: false});
+		});
+
+		it('should restore the sorted state of a table', function(){
+			var table = new HtmlTable({
+				sortable: true,
+				headers: ['col'],
+				parsers: ['number'],
+				rows: [[1],[0],[2]]
+			});
+			table.restore({sortIndex: 0, sortReverse: false});
+
+			var order = Array.map(table.body.rows, function(item){
+				return item.cells[0].get('text');
+			});
+
+			expect(order).toEqual(['0','1','2']);
+		});
+
+
+	});
+});

data/Packages/mootools-more/Tests/Specs/1.3/Interface/HtmlTable.Zebra.js

@@ -0,0 +1,39 @@
+describe('HtmlTable.Zebra', function(){
+
+	var getTable = function(){
+		return new HtmlTable({
+			rows: [[0],[1],[2]]
+		});
+	};
+
+	it('should alternate the zebra class on/off', function(){
+		var table = getTable();
+		var rows = table.body.getChildren();
+		expect(rows[0].hasClass('table-tr-odd')).toBeTruthy();
+		expect(rows[1].hasClass('table-tr-odd')).toBeFalsy();
+		expect(rows[2].hasClass('table-tr-odd')).toBeTruthy();
+	});
+
+	it('should update the zebras on row add/remove', function(){
+		var table = getTable();
+		table.push([3]);
+		table.push([4]);
+		var rows = table.body.getChildren();
+		expect(rows[3].hasClass('table-tr-odd')).toBeFalsy();
+		expect(rows[4].hasClass('table-tr-odd')).toBeTruthy();
+		
+		rows[3].dispose();
+		table.updateZebras();
+		expect(rows[3].hasClass('table-tr-odd')).toBeFalsy();
+	});
+
+	it('should ignore hidden rows for zebra classes', function(){
+		var table = getTable();
+		var rows = table.body.getChildren();
+		rows[1].setStyle('display','none');
+		table.updateZebras();
+		expect(rows[0].hasClass('table-tr-odd')).toBeTruthy();
+		expect(rows[2].hasClass('table-tr-odd')).toBeFalsy();
+	});
+
+});

data/Packages/mootools-more/Tests/Specs/1.3/Interface/HtmlTable.js

@@ -0,0 +1,153 @@
+/*
+---
+name: HtmlTable Tests
+requires: [More/HtmlTable]
+provides: [HtmlTable.Tests]
+...
+*/
+describe('HtmlTable', function(){
+
+	it('should create a new HtmlTable instance', function(){
+
+		var properties = {
+			border: '1',
+			cellspacing: '2',
+			cellpadding: '3',
+			'class': 'simple-table'
+		};
+
+		var t = new HtmlTable({
+			properties: properties,
+			headers: ['fruit', 'colors'],
+			footers: ['fruit', 'colors'],
+			rows: [
+				['lemon', 'yellow'],
+				['apple', 'red']
+			]
+		});
+
+		expect(t.thead.getElements('th').length).toEqual(2);
+		expect(t.body.getElements('td').length).toEqual(4);
+		expect(t.body.rows.length).toEqual(2);
+
+		expect($(t).get('border', 'cellspacing', 'cellpadding', 'class')).toEqual(properties);
+
+	});
+
+	describe('HtmlTable:push', function(){
+		var t = new HtmlTable(),
+			tds;
+
+		it('should push an multidimensional array', function(){
+			t.push([
+				'apple',
+				[
+					new Element('span', {'html': 'red'}),
+					new Element('span', {'html': '(green)'})
+				]
+			]);
+
+			tds = t.body.rows[0].getElements('td');
+			expect(tds.length).toEqual(2);
+			expect(tds[0].get('text')).toEqual('apple');
+			expect(tds[1].get('text')).toEqual('red(green)');
+		});
+
+		it('should push a simple array with text', function(){
+			t.push(['lemon', 'yellow']);
+			tds = t.body.rows[1].getElements('td');
+			expect(tds[0].get('text')).toEqual('lemon');
+			expect(tds[1].get('text')).toEqual('yellow');
+		});
+
+		it('should push an array with options and properties', function(){
+			t.push([{
+					content: 'grapes',
+					properties: {'class': 'someClass'}
+				},
+				'purple'
+			]);
+			tds = t.body.rows[2].getElements('td');
+			expect(tds[0].get('text', 'class')).toEqual({
+				text: 'grapes',
+				'class': 'someClass'
+			});
+			expect(tds[1].get('text')).toEqual('purple');
+		});
+
+		it('should complement the spanned row with a new td', function(){
+			t.push(['green']);
+			expect(t.body.rows[3].getElements('td').length).toEqual(1);
+		});
+
+		it('should push an tr element', function(){
+			var tr = new Element('tr').adopt(
+				new Element('td'),
+				new Element('td')
+			);
+			t.push(tr);
+			expect(t.body.rows[4]).toEqual(tr);
+		});
+
+		it('should return an object {tr: ..., tds: ...}', function(){
+			var value = t.push(['banana', 'yellow']);
+			expect(value.tr.get('tag')).toEqual('tr');
+			expect(value.tds.length).toEqual(2);
+		});
+
+		it('should push a row to the designated location', function(){
+			var rows = t.body.rows;
+			var value = t.push(['kiwi', 'green'], {}, rows[0], 'td', 'before');
+			expect(value.tr).toEqual(t.body.rows[0]);
+		});
+
+	});
+
+	describe('HtmlTable:pushMany', function(){
+		var t = new HtmlTable();
+		var rows = t.pushMany([
+				[1, 'one'],
+				[2, 'two'],
+				[3, 'three']
+			], {
+			'class': 'tableRowClass'
+		});
+		expect(rows.length).toEqual(3);
+		expect(t.body.rows.length).toEqual(3);
+		expect(rows[0].tr.get('class')).toEqual('tableRowClass');
+		tds = t.body.rows[0].getElements('td');
+		expect(tds.length).toEqual(2);
+		expect(tds[0].get('text')).toEqual('1');
+		expect(tds[1].get('text')).toEqual('one');
+
+	});
+
+	describe('HtmlTable cloned Element methods', function(){
+
+		var t = new HtmlTable({
+			rows: [
+				['lemon', 'yellow'],
+				['apple', 'red']
+			]
+		});
+
+		it('should inject the table in another element', function(){
+			var wrapper = new Element('div');
+			t.inject(wrapper);
+			expect(wrapper.contains($(t))).toBeTruthy();
+		});
+
+		it('should adopt another element into the table', function(){
+			var tr = new Element('tr').adopt(
+				new Element('td'),
+				new Element('td')
+			);
+			var ret = t.adopt(tr);
+
+			expect($(t).contains(tr)).toBeTruthy();
+			expect(ret).toEqual(t);
+		});
+
+	});
+
+});

data/Packages/mootools-more/Tests/Specs/1.3/Interface/Keyboard.js

@@ -0,0 +1,130 @@
+/*
+---
+name: Keyboard Tests
+requires: [More/Keyboard]
+provides: [Keyboard.Tests]
+...
+*/
+// Only run this spec in browsers other than IE6-8 because they can't properly simulate key events
+if (window.addEventListener) describe('Keyboard', function(){
+
+	it('should deactivate and reactivate', function(){
+
+		var onActivate = jasmine.createSpy(),
+		onDeactivate = jasmine.createSpy(),
+
+		kb = new Keyboard({
+			onActivate: onActivate,
+			onDeactivate: onDeactivate,
+			active: true
+		});
+
+		// events
+
+		kb.deactivate();
+		expect(onDeactivate).toHaveBeenCalled();
+
+		kb.activate();
+		expect(onActivate).toHaveBeenCalled();
+
+		expect(kb.isActive()).toEqual(true);
+
+		// toggle
+
+		kb.toggleActive();
+
+		expect(kb.isActive()).toEqual(false);
+
+		// options
+
+		var kb2 = new Keyboard({
+			active: true
+		});
+
+		expect(kb2.isActive()).toEqual(true);
+
+	});
+
+	it('should fire events for the given key combinations', function(){
+
+		var callback = jasmine.createSpy(), called = false;
+
+		var kb = new Keyboard({
+			events: {
+				'shift+;': callback
+			},
+			active: true
+		});
+
+		Syn.type('[shift];[shift-up]', document.body, function(){
+			called = true;
+		});
+
+		waitsFor(2, function(){
+			return called;
+		});
+
+		runs(function(){
+			expect(callback).toHaveBeenCalled();
+		});
+
+	});
+
+	xit('should bubble up the keyboard instances', function(){
+
+		var callback = jasmine.createSpy(), called = false;
+
+		var kb = new Keyboard({
+			events: {']': callback}
+		});
+
+		var kb2 = new Keyboard({
+			parent: kb
+		});
+
+		var kb3 = new Keyboard({
+			parent: kb2,
+			active: true
+		});
+
+		Syn.key(']', document.body, function(){
+			called = true;
+		});
+
+		waitsFor(2, function(){
+			return called;
+		});
+
+		runs(function(){
+			expect(callback).toHaveBeenCalled();
+		});
+
+	});
+
+	it('should fire the event on the onkeyup', function(){
+
+		var callback = jasmine.createSpy(), called;
+
+		var kb = new Keyboard({
+			events: {
+				'keyup:]': callback
+			},
+			active: true
+		});
+
+		Syn.key(']', document.body, function(){
+			called = true;
+		});
+
+		waitsFor(2, function(){
+			return called;
+		});
+
+		runs(function(){
+			expect(callback).toHaveBeenCalled();
+		});
+
+	});
+
+
+});

data/Packages/mootools-more/Tests/Specs/1.3/Locale/Locale.js

@@ -0,0 +1,104 @@
+/*
+---
+name: Locale Tests
+requires: [More/Locale, More/Locale.en-US.Form.Validator, More/Locale.en-US.Date, More/Locale.fr-FR.Date, More/Locale.en-US.Number]
+provides: [Locale.Tests]
+...
+*/
+
+describe('Locale', function(){
+
+	// In the specs there is only english available
+	Locale.define('fr-FR', 'FormValidator', {
+		required: 'Ce champ est obligatoire.'
+	});
+
+	it('should return english form validator message', function(){
+		Locale.use('en-US');
+		if (MooTools.lang) expect(MooTools.lang.get('FormValidator', 'required')).toEqual('This field is required.');
+
+		expect(Locale.get('FormValidator.required')).toEqual('This field is required.');
+	});
+
+	it('should cascade through to english', function(){
+		Locale.use('en-US');
+		expect(Locale.get('FormValidator.required')).toEqual('This field is required.');
+	});
+
+	it('should return french form validator message', function(){
+		Locale.use('fr-FR');
+
+		expect(Locale.get('FormValidator.required')).toEqual('Ce champ est obligatoire.');
+	});
+
+	it('should return the correct locale name', function(){
+		Locale.use('fr-FR');
+		expect(Locale.getCurrent().name).toEqual('fr-FR');
+		Locale.use('non-existsing');
+		expect(Locale.getCurrent().name).toEqual('fr-FR');
+	});
+
+	it('should inherit from other locales', function(){
+
+		Locale.define('nl-NL').inherit('en-US');
+
+		Locale.use('nl-NL');
+
+		Locale.define('nl-NL', 'Number', {
+			'foo': 'bar'
+		});
+
+		Locale.define('EU').inherit('World');
+		Locale.define('World', 'Number', {
+			'bar': 'foo'
+		}).inherit('EU'); // test for recursion
+
+		Locale.inherit('nl-NL', 'EU', 'Number');
+
+		expect(Locale.get('Number.foo')).toEqual('bar');
+		expect(Locale.get('Number.bar')).toEqual('foo');
+
+	});
+
+	it('should return a object when no key is specified', function(){
+		var obj = {
+			'guten': 'tag'
+		};
+
+		Locale.define('de-DE', 'Date', obj);
+		Locale.use('de-DE');
+
+		expect(Locale.get('Date')).toEqual(obj);
+	});
+
+	it('should return a cloned object without reference to the Locale.Set.data', function(){
+		Locale.define('de-DE', 'Ping', {
+			ping: 'w00fz, Stop mit Pingen'
+		});
+		Locale.use('de-DE');
+
+		expect(Locale.get('Ping') === Locale.get('Ping')).toBeFalsy();;
+	});
+
+	describe('MooTools.lang 1.2 specs', function(){
+
+		it('should return english form validator message', function(){
+			MooTools.lang.setLanguage('en-US');
+			expect(MooTools.lang.get('FormValidator', 'required')).toEqual('This field is required.');
+		});
+
+		it('should cascade through to english', function(){
+			MooTools.lang.set('en-GB', 'cascade', ['IT', 'ESP', 'gbENG']);
+			MooTools.lang.setLanguage('en-GB');
+			expect(MooTools.lang.get('FormValidator', 'required')).toEqual('This field is required.');
+		});
+
+		it('should return french form validator message', function(){
+			MooTools.lang.setLanguage('fr-FR');
+			expect(MooTools.lang.get('FormValidator', 'required')).toEqual('Ce champ est obligatoire.');
+		});
+
+
+	});
+
+});

data/Packages/mootools-more/Tests/Specs/1.3/Request/Request.JSONP.js

@@ -0,0 +1,55 @@
+/*
+---
+name: Request.JSONP Tests
+requires: [More/Request.JSONP]
+provides: [Request.JSONP.Tests]
+...
+*/
+describe('Request.JSONP', function(){
+
+	it('should grab some json from from assets/jsonp.js', function(){
+
+		var onComplete = jasmine.createSpy(),
+			complete = false,
+			timeout = false,
+			onRequest = jasmine.createSpy();
+
+		var request = new Request.JSONP({
+			log: true,
+			callbackKey: 'jsoncallback',
+			url: '../assets/jsonp.js',
+			timeout: 20000,
+			onComplete: function(){
+				onComplete.apply(this, arguments);
+				complete = true;
+			},
+			onRequest: function(src, script){
+				onRequest.call(this, src);
+				expect(script.get('tag')).toEqual('script');
+			},
+			onTimeout: function(){
+				timeout = true;
+			}
+		});
+
+		runs(function(){
+			request.send();
+		});
+
+		runs(function(){
+			expect(onRequest).toHaveBeenCalledWith('../assets/jsonp.js?jsoncallback=Request.JSONP.request_map.request_0');
+		});
+
+		waitsFor(1600, function(){
+			return complete || timeout;
+		});
+
+		runs(function(){
+			expect(onComplete).toHaveBeenCalled();
+			// See json.js file
+			expect(onComplete.mostRecentCall.args[0].test).toEqual(true);
+		});
+
+	});
+
+});