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

ninjs 0.13.7 → 0.13.8

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

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;
+}