RubyGems - ninjs - Versions diffs - 0.13.7 → 0.13.8 - Mend

ninjs 0.13.7 → 0.13.8

Files changed (275) hide show

data/repository/ninjs/extensions/jquery.elements.js ADDED Viewed

@@ -0,0 +1,60 @@
+(function($) {
+	NinjsModule.prototype.elements = function(elements, force) {
+		var self = this;
+		unless(is_defined(force), function() {
+			force = false;
+		});
+		if (is_string(elements)) {
+			var key = elements;
+			if (is_undefined(self.dom[key])) {
+				throw new SyntaxError("NinjsModule.elements('" + key + "'): " + self.name + ".dom." + key + " is undefined");
+			}
+			if (is_string(self.dom[key])) {
+				var selection = $(self.dom[key]);
+				unless(selection.length === 0, function() {
+					return self.dom[key] = selection;
+				}, function() {
+					return self.dom[key];
+				});
+			}
+			else {
+				if (self.dom[key].length === 0 || force) {
+					var return_obj = undefined;
+					if (is_string(force)) {
+						var selector = self.dom[key].selector;
+						self.dom[key] = $(force).find(selector);
+						self.dom[key].selector = selector;
+						return_obj = self.dom[key];
+					}
+					var selection = $(self.dom[key].selector);
+					unless(selection.length === 0, function() {
+						return_obj = selection;
+					});
+					return return_obj;
+				}
+				else {
+					return self.dom[key];
+				}
+			}
+		}
+		else if (is_typeof(Object, elements)) {
+			self.call_on_ready(function() {
+				for(var key in elements) {
+					if (elements.hasOwnProperty(key)) {
+						self.dom[key] = elements[key];
+					}
+				}
+			});
+		}
+	};
+})(jQuery);

data/repository/ninjs/tests/index.html ADDED Viewed

@@ -0,0 +1,21 @@
+<!DOCTYPE html>
+<head>
+	<title>All Ninjs tests</title>
+	<link rel="stylesheet" href="qunit/qunit.css" type="text/css" media="screen"/>
+	<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.4.4/jquery.min.js"></script>
+	<script src="qunit/qunit.js"></script>
+	<script src="../lib/nin.js"></script>
+	<script src="../lib/utilities.js"></script>
+	<script src="ninjs.test.js"></script>
+	<script src="ninjs.utilities.test.js"></script>
+</head>
+<body>
+	<h1 id="qunit-header">Ninjs tests</h1>
+	<h2 id="qunit-banner"></h2>
+	<h2 id="qunit-userAgent"></h2>
+	<ol id="qunit-tests"></ol>
+</body>

data/repository/ninjs/tests/ninjs.test.js ADDED Viewed

@@ -0,0 +1,188 @@
+module("existence tests");
+test("existence sanity check", function() {
+	ok(is_defined !== undefined, 'is_defined is defined');
+	ok(is_undefined !== undefined, 'is_undefined is defined');
+	ok(is_typeof !== undefined, 'is_typeof is defined');
+});
+test("can test for existence", function() {
+	var nonexistent;
+	var existent = 'I think';
+	equals(is_defined(existent), true, 'existent variable is_defined');
+	equals(is_defined(nonexistent), false, 'non-existent variable does not exist');
+});
+test("can test for non-existence", function() {
+	var existent = 'I think';
+	var nonexistent;
+	equals(is_undefined(nonexistent), true, 'non-existent variable does not exist');
+	equals(is_undefined(existent), false, 'existent variable does exist');
+});
+test("can check the type strictly with is_typeof", function() {
+	var foo = function(){};
+	var bar = {
+		name: 'SomeObject',
+		method: function() {}
+	};
+	var SomeClass = function(){};
+	var some_instance = new SomeClass();
+	equals(is_typeof(Number, 4), true, 'can check against Number');
+	equals(is_typeof(String, 'Hello World'), true, 'can check against String');
+	equals(is_typeof(Array, ['one', 'two', 'three']), true, 'can check against Array');
+	equals(is_typeof(Function, foo), true, 'can check against Function');
+	equals(is_typeof(Object, bar), true, 'can check against Object');
+	equals(is_typeof(RegExp, /pattern/), true, 'can check against Regexp');
+	equals(is_typeof(SomeClass, some_instance), true, 'can check against custom object');
+});
+module("typeof proxys");
+test("can check for default types", function() {
+	var today = new Date();
+	var easy_as = [1,2,3];
+	var pattern = new RegExp(/pattern/);
+	ok(is_string('hello'), 'hello is_string');
+	ok(is_number(42), '42 is_number');
+	ok(is_array(easy_as), 'easy_as is_array');
+	ok(is_bool(false), 'false is_bool');
+	ok(is_date(today), 'today is_date');
+	ok(is_regex(pattern), 'pattern is_regex');
+	equals(is_regex('hello'), false, 'hello fails is_regex');
+	equals(is_date(42), false, '42 fails is_date');
+	equals(is_bool(easy_as), false, 'easy_as fails is_bool');
+	equals(is_array(today), false, 'today fails is_array');
+	equals(is_number(true), false, 'true fails is_number');
+	equals(is_string(pattern), false, 'pattern fails is_string');
+});
+test("can determine a number", function() {
+	ok(is_numeric(2), '2 is a number');
+	ok(is_numeric(-2), '-2 is a number');
+	ok(is_numeric(45.6), '45.6 is a number');
+	ok(is_numeric(-45.6), '-45.6 is a number');
+	equals(is_numeric('45.6'), true, "'45.6 is a number'");
+	equals(is_numeric('Hello'), false, 'Hello is not a number');
+});
+module("extend tests");
+test("can add a method to the prototype", function() {
+	ok(is_defined(Function.prototype.method), "Object.prototype.method is defined");
+	String.method('test_method', function() {
+		return 'This is a test';
+	});
+	equals('Hello'.test_method(), 'This is a test', 'can create a prototype method with method');
+});
+test("can test a condition with unless", function() {
+   var is_true = false;
+   unless (false,
+      function() {
+         is_true = true;
+      }
+   );
+   ok(is_true, "unless works");
+   var does_fallback_work = false;
+   unless (true,
+      function() {
+      },
+      function() {
+         does_fallback_work = true;
+      }
+   );
+   ok(does_fallback_work, 'fallback works');
+});
+module("Ninjs application tests");
+test("can create a ninjs application object", function() {
+	var testapp = new NinjsApplication();
+	ok(is_defined(testapp), 'testapp is defined');
+	ok(is_typeof(NinjsApplication, testapp), 'testapp is a valid NinjsApplication');
+});
+test("can create a NinjsModule", function() {
+	var testapp = new NinjsApplication();
+	testapp.add_module('testmodule');
+	ok(is_defined(testapp.testmodule), 'testapp.testmodule is defined');
+	ok(is_typeof(NinjsModule, testapp.testmodule), 'testapp.testmodule is a valid NinjsModule');
+});
+module('Ninjs Module tests');
+test("module defaults", function() {
+	var testapp = new NinjsApplication();
+	testapp.add_module('testmodule');
+	// properties
+	ok(is_defined(testapp.testmodule.run_tests), 'testapp.testmodule.run_tests is defined');
+	equals(testapp.testmodule.run_tests, false, 'testapp.testmodule.run_tests defaults to false');
+	ok(is_defined(testapp.testmodule.data), "testapp.testmodule.data is defined");
+	ok(is_defined(testapp.testmodule.name), 'testapp.testmodule.name is defined');
+	equals(testapp.testmodule.name, 'testmodule', 'testapp.testmodule.name is correct');
+	ok(is_defined(testapp.testmodule.tests), 'testapp.testmodule.tests is defined');
+	ok(is_array(testapp.testmodule.tests), 'testapp.testmodule.tests is_array');
+	ok(testapp.testmodule.tests.is_empty(), 'testapp.testmodule.tests is empty');
+	ok(is_defined(app), 'app is defined');
+	// methods
+	ok(is_defined(testapp.testmodule.actions), 'testapp.testmodule.actions is defined');
+	ok(is_typeof(Function, testapp.testmodule.actions), "testapp.testmodule.actions is a valid Function");
+	ok(is_defined(testapp.testmodule.run), 'testapp.testmodule.run is defined');
+	ok(is_typeof(Function, testapp.testmodule.run), "testapp.testmodule.run is a valid Function");
+	ok(is_defined(testapp.testmodule.call_on_ready), 'testmodule.testapp.call_on_ready is defined');
+	ok(is_defined(testapp.testmodule.execute), 'testmodule.testapp.execute is defined');
+	ok(is_defined(testapp.testmodule.elements), 'testapp.testmodule.elements is defined');
+	ok(is_defined(testapp.testmodule.set_data), 'testapp.testmodule.set_data is defined');
+});
+test("add_module returns the created module", function() {
+   var testapp = new NinjsApplication();
+   var module = testapp.add_module('some_module');
+   equals(module, testapp.some_module, 'hey');
+});
+// Qunit waits for DOM to load before running tests
+// to test DOM wait feature, we need to run some code outside the tests
+(function() {
+	var testapp = new NinjsApplication();
+	testapp.add_module('testmodule');
+	testapp.testmodule.actions = function() {
+		// append an element to be sure the DOM is ready for manipulation and test for the element's existence
+		$('body').append('<div id="made-by-actions"/>');
+		test("Ninjs module can run actions", function() {
+			equals($('#made-by-actions').length, 1,'testapp.test.actions ran after DOM was ready');
+		});
+	};
+	testapp.testmodule.run();
+}());
+// Qunit waits for DOM to load before running tests
+// to test DOM wait feature, we need to run some code outside the tests
+(function() {
+	var testapp = new NinjsApplication();
+	testapp.add_module('testmodule');
+	testapp.testmodule.elements(function() {
+		testapp.testmodule.qunit_header = $('#qunit-header');
+		testapp.testmodule.qunit_banner = $('#qunit-banner');
+		test('Ninjs module can cache elements', function() {
+			equals(testapp.testmodule.qunit_header[0].tagName, 'H1', '#qunit-header returns an h1');
+			equals(testapp.testmodule.qunit_banner[0].tagName, 'H2', '#qunit-banner returns an h2');
+		});
+	});
+}());

data/repository/ninjs/tests/ninjs.utilities.test.js ADDED Viewed

@@ -0,0 +1,137 @@
+module("array utility tests");
+test("can test for emptiness", function() {
+	expect(4);
+	ok([].is_empty(), "[].is_empty() is true");
+	equals(['one', 'two', 'three'].is_empty(), false, "['one', 'two', 'three'].is_empty()");
+	ok(['one', 'two', 'three'].not_empty(), "['one', 'two', 'three'].not_empty() is false");
+	equals([].not_empty(), false, "[].not_empty() is false");
+});
+test("can iterate over each element", function() {
+	expect(7);
+	var iteration_count = 0;
+	var test_array_values = [];
+	var test_array_indices = [];
+	['one', 'two', 'three'].each(function(value, index) {
+		iteration_count++;
+		test_array_values.push(value);
+		test_array_indices.push(index);
+	});
+	equals(test_array_values[0], 'one', 'value at index 0 is correct');
+	equals(test_array_values[1], 'two', 'value at index 1 is correct');
+	equals(test_array_values[2], 'three', 'value at index 2 is correct');
+	equals(test_array_indices[0], 0, 'first index is correct');
+	equals(test_array_indices[1], 1, 'second index is correct');
+	equals(test_array_indices[2], 2, 'third index is correct');
+	equals(iteration_count, 3, 'made only three iterations');
+});
+test("can test if an array contains an element", function() {
+	var array = ['one', 'two', 'three'];
+	var string = 'hello';
+	var object = {
+		name: 'some object'
+	};
+	var number = 45;
+	var date = new Date();
+	var test_array = [array, string, object, number, date];
+	ok(test_array.contains(array), 'array.contains(array)');
+	ok(test_array.contains(string), 'array.contains(string)');
+	ok(test_array.contains(object), 'array.contains(object)');
+	ok(test_array.contains(number), 'array.contains(number)');
+	ok(test_array.contains(date), 'array.contains(date)');
+	equals(test_array.contains('not in there'), false, 'non-existent value is false');
+});
+module("string utility tests");
+test("can test for emptiness", function() {
+	ok(''.is_empty(), "''.is_empty() is true");
+	equals('hey there'.is_empty(), false, "'hey there'.is_empty() is false");
+	ok('hey there'.not_empty(), "'hey there'.not_empty() is false");
+	equals(''.not_empty(), false, "''.not_empty() is false");
+});
+test('can test for number', function() {
+	equals('34'.is_numeric(), true, "34 is numeric");
+	equals('0.5'.is_numeric(), true, ".5 is numeric");
+	equals('-34'.is_numeric(), true, '-34 is numeric');
+	equals('-0.5'.is_numeric(), true, '-.05 is numeric');
+	equals('hello'.is_numeric(), false, 'hello is numeric');
+});
+test('can trim a string', function() {
+	equals(' hello '.trim(), 'hello', "' hello '.trim()");
+	equals(' hello '.ltrim(), 'hello ', "' hello '.ltrim()");
+	equals(' hello '.rtrim(), ' hello', "' hello '.rtrim()");
+});
+test("can iterate over each character", function() {
+	var iteration_count = 0;
+	var test_chars = [];
+	var test_indices = [];
+	'123'.each(function(character, index) {
+		test_chars.push(character);
+		test_indices.push(index);
+		iteration_count++;
+	});
+	equals(test_chars[0], '1', 'first character of 123 is 1');
+	equals(test_chars[1], '2', 'second character of 123 is 2');
+	equals(test_chars[2], '3', 'second character of 123 is 3');
+	equals(test_indices[0], 0, 'first index is correct');
+	equals(test_indices[1], 1, 'second index is correct');
+	equals(test_indices[2], 2, 'third index is correct');
+	equals(iteration_count, 3, 'made only three iterations');
+});
+test('can capitalize a string', function() {
+	equals('hello world'.capitalize(), 'Hello world', 'capitalized string correctly');
+});
+test('can reverse a string', function() {
+	equals('hello world'.reverse(), 'dlrow olleh', 'reversed string correctly');
+	equals('satan oscillate my metallic sonatas'.reverse(), 'satanos cillatem ym etallicso natas', 'fucking palindromes, how do they work?');
+});
+test("can convert to number", function() {
+	var whole_number = '32';
+	var decimal = '0.08';
+	var negative_number = '-32';
+	var negative_float = '-0.08';
+	same(whole_number.to_n(), 32, "whole_number.to_n() is 32");
+	same(decimal.to_n(), 0.08, "decimal.to_n() is 0.08");
+	same(negative_number.to_n(), -32, "negative_number.to_n() is -32");
+	same(negative_float.to_n(), -0.08, "negative_float.to_n() -0.08");
+});
+test("can pluck a string", function() {
+	equals('one, two, three'.pluck(','), 'one two three', "'one, two, three'.pluck(',')");
+});
+test("can single space a string", function() {
+	var hard_space = 'one&nbsp;two&nbsp;&nbsp;three&nbsp;&nbsp;&nbsp;four&nbsp;&nbsp;&nbsp;&nbsp;five&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;six';
+	var soft_space = 'one two  three   four    five     six';
+	var mixed_space = 'one two &nbsp; three &nbsp;&nbsp;four &nbsp;&nbsp;&nbsp;five &nbsp;&nbsp;&nbsp;&nbsp;six';
+	equals(hard_space.single_space(), 'one two three four five six', 'correctly spaced &nbsp;');
+	equals(soft_space.single_space(), 'one two three four five six', "correctly spaced soft spaces");
+	equals(mixed_space.single_space(), 'one two three four five six', "correctly spaced mixed spaces");
+});
+test("can compress a string", function() {
+	var string = "satan\n\t oscillate\n\t my\n\t metallic\n sonatas";
+	same(string.compress(), 'satanoscillatemymetallicsonatas', "string is compressed correctly");
+});

data/repository/ninjs/tests/qunit/qunit.css ADDED Viewed

@@ -0,0 +1,197 @@
+/** Font Family and Sizes */
+#qunit-tests, #qunit-header, #qunit-banner, #qunit-testrunner-toolbar, #qunit-userAgent, #qunit-testresult {
+	font-family: "Helvetica Neue Light", "HelveticaNeue-Light", "Helvetica Neue", Calibri, Helvetica, Arial;
+}
+#qunit-testrunner-toolbar, #qunit-userAgent, #qunit-testresult, #qunit-tests li { font-size: small; }
+#qunit-tests { font-size: smaller; }
+/** Resets */
+#qunit-tests, #qunit-tests ol, #qunit-header, #qunit-banner, #qunit-userAgent, #qunit-testresult {
+	margin: 0;
+	padding: 0;
+}
+/** Header */
+#qunit-header {
+	padding: 0.5em 0 0.5em 1em;
+	color: #8699a4;
+	background-color: #0d3349;
+	font-size: 1.5em;
+	line-height: 1em;
+	font-weight: normal;
+	border-radius: 15px 15px 0 0;
+	-moz-border-radius: 15px 15px 0 0;
+	-webkit-border-top-right-radius: 15px;
+	-webkit-border-top-left-radius: 15px;
+}
+#qunit-header a {
+	text-decoration: none;
+	color: #c2ccd1;
+}
+#qunit-header a:hover,
+#qunit-header a:focus {
+	color: #fff;
+}
+#qunit-banner {
+	height: 5px;
+}
+#qunit-testrunner-toolbar {
+	padding: 0.5em 0 0.5em 2em;
+	color: #5E740B;
+	background-color: #eee;
+}
+#qunit-userAgent {
+	padding: 0.5em 0 0.5em 2.5em;
+	background-color: #2b81af;
+	color: #fff;
+	text-shadow: rgba(0, 0, 0, 0.5) 2px 2px 1px;
+}
+/** Tests: Pass/Fail */
+#qunit-tests {
+	list-style-position: inside;
+}
+#qunit-tests li {
+	padding: 0.4em 0.5em 0.4em 2.5em;
+	border-bottom: 1px solid #fff;
+	list-style-position: inside;
+}
+#qunit-tests li strong {
+	cursor: pointer;
+}
+#qunit-tests ol {
+	margin-top: 0.5em;
+	padding: 0.5em;
+	background-color: #fff;
+	border-radius: 15px;
+	-moz-border-radius: 15px;
+	-webkit-border-radius: 15px;
+	box-shadow: inset 0px 2px 13px #999;
+	-moz-box-shadow: inset 0px 2px 13px #999;
+	-webkit-box-shadow: inset 0px 2px 13px #999;
+}
+#qunit-tests table {
+	border-collapse: collapse;
+	margin-top: .2em;
+}
+#qunit-tests th {
+	text-align: right;
+	vertical-align: top;
+	padding: 0 .5em 0 0;
+}
+#qunit-tests td {
+	vertical-align: top;
+}
+#qunit-tests pre {
+	margin: 0;
+	white-space: pre-wrap;
+	word-wrap: break-word;
+}
+#qunit-tests del {
+	background-color: #e0f2be;
+	color: #374e0c;
+	text-decoration: none;
+}
+#qunit-tests ins {
+	background-color: #ffcaca;
+	color: #500;
+	text-decoration: none;
+}
+/*** Test Counts */
+#qunit-tests b.counts                       { color: black; }
+#qunit-tests b.passed                       { color: #5E740B; }
+#qunit-tests b.failed                       { color: #710909; }
+#qunit-tests li li {
+	margin: 0.5em;
+	padding: 0.4em 0.5em 0.4em 0.5em;
+	background-color: #fff;
+	border-bottom: none;
+	list-style-position: inside;
+}
+/*** Passing Styles */
+#qunit-tests li li.pass {
+	color: #5E740B;
+	background-color: #fff;
+	border-left: 26px solid #C6E746;
+}
+#qunit-tests .pass                          { color: #528CE0; background-color: #D2E0E6; }
+#qunit-tests .pass .test-name               { color: #366097; }
+#qunit-tests .pass .test-actual,
+#qunit-tests .pass .test-expected           { color: #999999; }
+#qunit-banner.qunit-pass                    { background-color: #C6E746; }
+/*** Failing Styles */
+#qunit-tests li li.fail {
+	color: #710909;
+	background-color: #fff;
+	border-left: 26px solid #EE5757;
+}
+#qunit-tests .fail                          { color: #000000; background-color: #EE5757; }
+#qunit-tests .fail .test-name,
+#qunit-tests .fail .module-name             { color: #000000; }
+#qunit-tests .fail .test-actual             { color: #EE5757; }
+#qunit-tests .fail .test-expected           { color: green;   }
+#qunit-banner.qunit-fail                    { background-color: #EE5757; }
+/** Footer */
+#qunit-testresult {
+	padding: 0.5em 0.5em 0.5em 2.5em;
+	color: #2b81af;
+	background-color: #D2E0E6;
+	border-radius: 0 0 15px 15px;
+	-moz-border-radius: 0 0 15px 15px;
+	-webkit-border-bottom-right-radius: 15px;
+	-webkit-border-bottom-left-radius: 15px;
+}
+/** Fixture */
+#qunit-fixture {
+	position: absolute;
+	top: -10000px;
+	left: -10000px;
+}