demos/data-set-deprecated/index.html

<!DOCTYPE html>

<html>
<head>
	<meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
	<script src="../../build/aui/aui.js" type="text/javascript"></script>

	<link href="../../build/aui-css/css/bootstrap.css" rel="stylesheet" />
	<link href="../../build/aui-skin-deprecated/css/aui-skin-deprecated.css" media="screen" rel="stylesheet" type="text/css" />

	<style media="screen" type="text/css">
		body {
			font-size: 12px;
		}

		#wrapper {
			padding: 10px;
		}
	</style>
</head>

<body>

<div id="wrapper">
	<h1>Alloy - Data Set Demo</h1>


	<div class="yui3-skin-sam" id="demo"></div>
</div>

<script type="text/javascript" charset="utf-8">
YUI(
	{
		filter: 'raw',
		logInclude: {
			TestRunner: true
		}
	}
).use(
	'aui-data-set-deprecated',
	'console',
	'test',
	function(A) {
		var col = new A.DataSet;

		var dataSetTests = new A.Test.Case(
			{
				name: 'DataSetTests',

				setUp: function() {
					var instance = this;

					instance.myGuid = A.guid();
					instance.myData = { testVal: instance.myGuid };
					instance.myCol = new A.DataSet;

					instance.myCol.add('keyAdd', instance.myData);
				},

				testAdd: function() {
					var instance = this;

					var col = instance.myCol;

					var guid1 = A.guid();
					col.add(
						'key2',
						{
							testVal: guid1
						}
					);

					A.Assert.areSame(2, col.size());
					A.Assert.areSame(guid1, col.item('key2').testVal);
					A.Assert.areSame(guid1, col.item(1).testVal);

					var guid2 = A.guid();
					col.add(
						{
							id: 55,
							testVal: guid2
						}
					);

					A.Assert.areSame(3, col.size());
					A.Assert.areSame(guid2, col.item(2).testVal);
					A.Assert.areSame(55, col.getKey(col.item(2)));
				},

				testAddAll: function() {
					var instance = this;

					var col = instance.myCol;

					col.addAll(
						{
							key2: 2,
							key3: 3,
							key4: 4,
							key5: 5
						}
					);

					A.Assert.areSame(5, col.size());
					A.Assert.areSame(2, col.item(1));
					A.Assert.areSame(2, col.indexOf(3));

					col.clear();

					col.addAll(
						[
							{
								id: 'keyX1',
								value: 1
							},
							{
								id: 'keyX2',
								value: 2
							},
							{
								id: 'keyX3',
								value: 3
							},
							{
								id: 'keyX4',
								value: 4
							}
						]
					);

					A.Assert.areSame(1, col.item('keyX1').value);
					A.Assert.areSame(4, col.size());
					A.Assert.areSame(4, col.get('last').value);
					A.Assert.areSame(2, col.item(1).value);
					A.Assert.areSame(true, col.containsKey('keyX3'));
				},

				testClear: function() {
					var instance = this;

					var col = instance.myCol;

					col.clear();

					A.Assert.areSame(0, col.size());
					A.Assert.areSame(0, col.get('values').length);
					A.Assert.areSame(0, col.get('keys').length);
				},

				testClone: function() {
					var instance = this;

					var col2 = instance.myCol.clone();

					A.Assert.areSame(instance.myCol.size(), col2.size());
					col2.add('keyCloneAdd', {test4: instance.myGuid});
					A.Assert.areNotSame(instance.myCol.size(), col2.size());
				},

				testContains: function() {
					var instance = this;

					var col = instance.myCol;

					col.addAll(
						{
							key2: 2,
							key3: 3,
							key4: 4,
							key5: 5
						}
					);

					var key6Obj = {
						id: 'keyX1',
						value: 1
					};

					col.add('key6', key6Obj);

					A.Assert.areSame(true, col.contains(key6Obj));
					A.Assert.areSame(true, col.contains(2));
					A.Assert.areSame(false, col.contains(88));
				},

				testContainsKey: function() {
					var instance = this;

					var col = instance.myCol;

					col.addAll(
						{
							key2: 2,
							key3: 3,
							key4: 4,
							key5: 5
						}
					);

					var key6Obj = {
						id: 'keyX1',
						value: 1
					};

					col.add('key6', key6Obj);

					A.Assert.areSame(true, col.containsKey('key6'));
					A.Assert.areSame(true, col.containsKey('key2'));
					A.Assert.areSame(false, col.containsKey('keyUndefined'));
				},

				testEach: function() {
					var instance = this;

					var col = instance.myCol;

					col.clear();

					col.addAll(
						{
							key2: 2,
							key3: 3,
							key4: 4,
							key5: 5
						}
					);

					var indices = [];
					var values = [];
					var shortValues = [];

					col.each(
						function(item, index) {
							indices.push(index);
							values.push(item);
						}
					);

					A.ArrayAssert.itemsAreEqual([2,3,4,5], values);
					A.ArrayAssert.itemsAreEqual([0,1,2,3], indices);

					col.each(
						function(item, index) {
							shortValues.push(item);

							if (index > 1) {
								return false;
							}
						}
					);

					A.ArrayAssert.itemsAreEqual([2,3,4], shortValues);
				},

				testEachKey: function() {
					var instance = this;

					var col = instance.myCol;

					col.clear();

					col.addAll(
						{
							key2: 2,
							key3: 3,
							key4: 4,
							key5: 5
						}
					);

					var indices = [];
					var keys = [];

					col.eachKey(
						function(item, index, collection) {
							indices.push(index);
							keys.push(item);
						}
					);

					A.ArrayAssert.itemsAreEqual(['key2','key3','key4','key5'], keys);
					A.ArrayAssert.itemsAreEqual([0,1,2,3], indices);
				},

				testFilter: function() {
					var instance = this;

					var col = instance.myCol;

					col.addAll(
						{
							key2: 2,
							key3: 3,
							key4: 4,
							key5: 5
						}
					);

					var newCol = col.filter(
						function(item, index) {
							return item > 3;
						}
					);

					A.Assert.areSame(undefined, newCol.item('key2'));
					A.Assert.areSame(2, newCol.size());
				},

				testFilterBy: function() {
					var instance = this;

					var col = instance.myCol;

					col.addAll(
						[
							{
								key2: '2 is here',
								key3: '3 is not here',
								key4: '4 is gone again',
								key5: '5 was here yesterday'
							},
							{
								key2: 'hello 2',
								key3: 'hello 3',
								key4: 'hello 4',
								key5: 'hello 5'
							},
							{
								key2: 'another 2',
								key3: 'another 3',
								key4: 'another 4',
								key5: 'another 5'
							},
							{
								key2: 'and again is 2',
								key3: 'and again is 3',
								key4: 'and again is 4',
								key5: 'and again is 5'
							}
						]
					);

					var newCol = col.filterBy('key2', '2');

					A.Assert.areSame(undefined, newCol.item(1));
					A.Assert.areSame(1, newCol.size());

					var newCol2 = col.filterBy('key2', 'is', false);

					A.Assert.areSame(2, newCol2.size());
					A.Assert.areSame('and again is 3', newCol2.item(1).key3);
				},

				testFindIndex: function() {
					var instance = this;

					var col = instance.myCol;

					col.addAll(
						[
							{
								key2: '2 is here',
								key3: '3 is not here',
								key4: '4 is gone again',
								key5: '5 was here yesterday'
							},
							{
								key2: 'hello 2',
								key3: 'hello 3',
								key4: 'hello 4',
								key5: 'hello 5'
							},
							{
								key2: 'another 2',
								key3: 'another 3',
								key4: 'another 4',
								key5: 'another 5'
							},
							{
								key2: 'and again is 2',
								key3: 'and again is 3',
								key4: 'and again is 4',
								key5: 'and again is 5'
							}
						]
					);

					var index = col.findIndex(function(item, index, collection) {
						if (item.key2 && item.key2.indexOf('hello') > -1) {
							return true;
						}
					});

					A.Assert.areSame(2, index);
				},

				testFindIndexBy: function() {
					var instance = this;

					var col = instance.myCol;

					col.addAll(
						[
							{
								key2: '2 is here',
								key3: '3 is not here',
								key4: '4 is gone again',
								key5: '5 was here yesterday'
							},
							{
								key2: 'hello 2',
								key3: 'hello 3',
								key4: 'hello 4',
								key5: 'hello 5'
							},
							{
								key2: 'another WAS 2',
								key3: 'another was 3',
								key4: 'another was 4',
								key5: 'another was 5'
							},
							{
								key2: 'and again is 2',
								key3: 'and again is 3',
								key4: 'and again is 4',
								key5: 'and again is 5'
							}
						]
					);

					var index = col.findIndexBy('key2', '2');

					A.Assert.areSame(1, index);

					var index2 = col.findIndexBy('key2', 'was');

					A.Assert.areSame(-1, index2);

					var index3 = col.findIndexBy('key2', 'was', 0, false);

					A.Assert.areSame(3, index3);

					var index4 = col.findIndexBy('key2', 'is', 2, false);

					A.Assert.areSame(4, index4);

					var index5 = col.findIndexBy('key2', 'is', 2, false, true);

					A.Assert.areSame(4, index5);

					var index5 = col.findIndexBy('key2', 'WAS', 0, false, true);

					A.Assert.areSame(3, index5);

				},

				testIndexOf: function() {
					var instance = this;

					A.Assert.areSame(0, instance.myCol.indexOf(instance.myData));
				},

				testIndexOfKey: function() {
					var instance = this;

					A.Assert.areSame(0, instance.myCol.indexOfKey('keyAdd'));
				},

				testInsert: function() {
					var instance = this;

					var col = instance.myCol;

					col.addAll(
						{
							key2: 2,
							key3: 3,
							key4: 4,
							key5: 5
						}
					);

					col.insert(1, 'key1a', 100);

					A.Assert.areSame(100, col.item('key1a'));
					A.Assert.areSame(100, col.item(1));
					A.Assert.areSame(6, col.size());
				},

				testInvoke: function() {
					var instance = this;

					var col = instance.myCol;

					var testVal = 10;

					col.addAll(
						{
							key2: [],
							key3: {
								run: function(n) {
									testVal *= n;
									return testVal;
								}
							}
						}
					);

					var newVal = instance.myCol.invoke('run', 10);

					A.Assert.areSame(100, testVal);

					instance.myCol.invoke('push', [5,6,7]);

					A.ArrayAssert.itemsAreEqual([5,6,7], col.item('key2'));
				},

				testItem: function() {
					var instance = this;

					A.Assert.areSame(instance.myData, instance.myCol.item(0));
				},

				testKeySort: function() {
					var instance = this;

					var col = instance.myCol;

					col.clear();

					col.addAll(
						{
							key3: 3,
							key2: 2,
							key5: 5,
							key4: 4
						}
					);

					col.keySort('desc');

					A.ArrayAssert.itemsAreEqual(['key5', 'key4', 'key3', 'key2'], col.get('keys'));

					col.keySort('asc');

					A.ArrayAssert.itemsAreEqual(['key2', 'key3', 'key4', 'key5'], col.get('keys'));
				},

				testRemove: function() {
					var instance = this;

					var col = instance.myCol;

					col.addAll(
						{
							key2: 2,
							key3: 3,
							key4: 4,
							key5: 5
						}
					);

					col.remove(4);

					A.Assert.areSame(undefined, col.item('key4'));
					A.Assert.areSame(4, col.size());
				},

				testPreventAdd: function() {
					var instance = this;

					var col = instance.myCol;

					var handle = col.on(
						'add',
						function(event) {
							event.preventDefault();
						}
					);

					var guid1 = A.guid();
					col.add('key2', {testVal: guid1});

					A.Assert.areSame(1, col.size());

					handle.detach();

					var guid2 = A.guid();
					col.add({id: 55, testVal: guid2});

					A.Assert.areSame(2, col.size());
					A.Assert.areSame(guid2, col.item(1).testVal);
					A.Assert.areSame(55, col.getKey(col.item(1)));
				},

				testPreventClear: function() {
					var instance = this;

					var col = instance.myCol;

					var handle = col.on(
						'clear',
						function(event) {
							event.preventDefault();
						}
					);

					col.clear();

					A.Assert.areNotSame(0, col.size());
					A.Assert.areNotSame(0, col.get('values').length);
					A.Assert.areNotSame(0, col.get('keys').length);
				},

				testPreventRemove: function() {
					var instance = this;

					var col = instance.myCol;

					var handle = col.on(
						'remove',
						function(event) {
							event.preventDefault();
						}
					);

					col.addAll(
						{
							key2: 2,
							key3: 3,
							key4: 4,
							key5: 5
						}
					);

					col.remove(4);

					A.Assert.areNotSame(undefined, col.item('key4'));
					A.Assert.areNotSame(4, col.size());
				},

				testPreventReplace: function() {
					var instance = this;

					var col = instance.myCol;

					col.addAll(
						{
							key2: 2,
							key3: 3,
							key4: 4,
							key5: 5
						}
					);

					var handle = col.on(
						'replace',
						function(event) {
							event.preventDefault();
						}
					);

					col.replace('key3', 100);

					col.replace('key6', 88);

					A.Assert.areSame(3, col.item('key3'));
					A.Assert.areSame(6, col.size());
					A.Assert.areNotSame(88, col.get('key6'));
				},

				testPreventSort: function() {
					var instance = this;

					var col = instance.myCol;

					col.clear();

					var handle = col.on(
						'sort',
						function(event) {
							event.preventDefault();
						}
					);

					col.addAll(
						{
							key3: 3,
							key2: 2,
							key5: 5,
							key4: 4
						}
					);

					col.sort('desc');

					A.ArrayAssert.itemsAreEqual([3, 2, 5, 4], col.get('values'));

					col.sort('asc');

					A.ArrayAssert.itemsAreEqual([3, 2, 5, 4], col.get('values'));
				},

				testRemoveAt: function() {
					var instance = this;

					var col = instance.myCol;

					col.addAll(
						{
							key2: 2,
							key3: 3,
							key4: 4,
							key5: 5
						}
					);

					col.removeAt(1);

					A.Assert.areSame(undefined, col.item('key2'));
					A.Assert.areSame(4, col.size());

					col.removeAt(1);

					A.Assert.areSame(4, col.item(1));
					A.Assert.areSame(3, col.size());
				},

				testRemoveKey: function() {
					var instance = this;

					var col = instance.myCol;

					col.addAll(
						{
							key2: 2,
							key3: 3,
							key4: 4,
							key5: 5
						}
					);

					col.removeKey('key2');

					A.Assert.areSame(undefined, col.item('key2'));
					A.Assert.areSame(4, col.size());
				},

				testReplace: function() {
					var instance = this;

					var col = instance.myCol;

					col.addAll(
						{
							key2: 2,
							key3: 3,
							key4: 4,
							key5: 5
						}
					);

					col.replace('key3', 100);

					col.replace('key6', 88);

					A.Assert.areSame(100, col.item('key3'));
					A.Assert.areSame(6, col.size());
					A.Assert.areSame(88, col.get('last'));
				},

				testSize: function() {
					var instance = this;

					A.Assert.areSame(1, instance.myCol.size());
				},

				testSlice: function() {
					var instance = this;

					var col = instance.myCol;

					col.addAll(
						{
							key2: 2,
							key3: 3,
							key4: 4,
							key5: 5
						}
					);

					A.ArrayAssert.itemsAreEqual([2], col.slice(1, 2));
					A.ArrayAssert.itemsAreEqual([2, 3, 4, 5], col.slice(1));
				},

				testSort: function() {
					var instance = this;

					var col = instance.myCol;

					col.clear();

					col.addAll(
						{
							key3: 3,
							key2: 2,
							key5: 5,
							key4: 4
						}
					);

					col.sort('desc');

					A.ArrayAssert.itemsAreEqual([5, 4, 3, 2], col.get('values'));

					col.sort('asc');

					A.ArrayAssert.itemsAreEqual([2, 3, 4, 5], col.get('values'));
				}
			}
		);

		new A.Console(
			{
				newestOnTop: false
			}
		).render('#demo');

		A.Test.Runner.add(dataSetTests);
		A.Test.Runner.run();
	}
);
</script>

</body>
</html>