ninjs 0.13.8 → 0.14.0

data/repository/ninjs/core/extend.js

@@ -1,77 +1,35 @@
-/* File: extend.js */
-//= require "existence"
-
-if (is_undefined(Function.prototype['method'])) {
-   /*   
-      Function: method
-         Method to add a method to an object (ie. String.method('my_method', my_func); // 'hello'.my_method())
-
-      Parameters:
-         name - name of the method
-         func - function definition
-
-      Returns:
-         this (chainable)
-         
-      > String.method('custom_method', function() {
-      >    // define custom_method
-      > });
-      >
-      > "hello".custom_method();
-   */
-	Function.prototype.method = function(name, func) {
-		if (is_undefined(name)) {
-			throw new SyntaxError("Object.method(name, func): name is undefined");
-		}
-		
-		if (is_undefined(func)) {
-			throw new SyntaxError("Object.method(name, func): func is undefined");
-		}
-
-		if (is_undefined(this.prototype[name])) {
-			this.prototype[name] = func;
-			return this;
-		}
-	};
-}
-
-if (is_undefined(unless)) {
-   /*   
-      Function: unless
-         Function to better express negative conditions (ie. if (!something))
-
-      Parameters:
-         expression - expression to be tested
-         callback - function to be executed unless expression is true (see how that works)
-         fallback - function to be executed if the expression is false (optional)
-
-      Returns:
-         undefined
-         
-      > unless(test_expression === 'some condition',
-      >   function() {
-      >         alert('we do something');
-      >    },
-      >    function() {
-      >        alert('we can do something if it meets the condition too');
-      >    }
-      > );
-   */
-   var unless = function(expression, callback, fallback) {
-		if (is_undefined(expression)) {
-			throw new SyntaxError("unless(expression, callback[, fallback]): expression is undefined");
-		}
-
-		if (is_undefined(callback)) {
-			throw new SyntaxError("unless(expression, callback[, fallback]): callback is undefined");
-		}
-
-		// This kind of expression is exactly why we NEED unless
-		if (!expression) {
-			callback.call(this);
-		}
-		else if (is_defined(fallback)) {
-			fallback.call(this);
-		}
-   };
-}
+	if (is_undefined(Function.prototype['method'])) {
+		Function.prototype.method = function(name, func) {
+			if (is_undefined(name)) {
+				throw new SyntaxError("Object.method(name, func): name is undefined");
+			}
+
+			if (is_undefined(func)) {
+				throw new SyntaxError("Object.method(name, func): func is undefined");
+			}
+
+			if (is_undefined(this.prototype[name])) {
+				this.prototype[name] = func;
+				return this;
+			}
+		};
+	}
+
+	if (is_undefined(window.unless)) {
+	   window.unless = function(expression, callback, fallback) {
+			if (is_undefined(expression)) {
+				throw new SyntaxError("unless(expression, callback[, fallback]): expression is undefined");
+			}
+
+			if (is_undefined(callback)) {
+				throw new SyntaxError("unless(expression, callback[, fallback]): callback is undefined");
+			}
+
+			if (!expression) {
+				callback.call(this);
+			}
+			else if (is_defined(fallback)) {
+				fallback.call(this);
+			}
+	   };
+	}

data/repository/ninjs/core/module.js

@@ -1,135 +1,120 @@
-var NinjsModule = function(name) {
-	this.dom = {};
-	this.data = {};
-	this.name = name;
-	this.run_tests = false;
-	this.tests = [];
-};
+	window.NinjsModule = function(name) {
+		this.dom = new NinjsDOM(this);
+		this.browser = browser;
+		this.data = {};
+		this.name = name;
+		this.run_tests = false;
+		this.tests = [];
+	};
 
-NinjsModule.method('actions', function() {});
+	NinjsModule.method('actions', function() {});
 
-NinjsModule.method('run', function() {
-	this.call_on_ready(this.execute);
-});
-
-NinjsModule.method('call_on_ready', function(callback) {
-	var timer;
-	var module = this;
-
-	function check_ready() {
-		timer = setInterval(is_ready, 13);
-	}
+	NinjsModule.method('run', function() {
+		var mod = this;
+		this.dom.ready(function() {
+			mod.execute();
+		});
+	});
 
-	function is_ready() {
-		if (document && document.getElementsByTagName && document.getElementById && document.body) {
-			clearInterval(timer);
-			timer = null;
-			callback.call(module);
+	NinjsModule.method('execute', function() {
+		if (this.run_tests) {
+			this._run_tests();
 		}
-	}
 
-	check_ready();
-});
+		this.actions();
+	});
 
-NinjsModule.method('execute', function() {	
-	if (this.run_tests) {
-		this._run_tests();
-	}
-	
-	this.actions();
-});
+	NinjsModule.method('elements', function(elements) {
+		if (is_undefined(elements)) {
+		   if (is_typeof(Object, elements)) {
+		      throw new SyntaxError("NinjsModule.elements(elements): elements is undefined");
+		   }
+		   else if (is_string(elements)) {
+		      throw new SyntaxError("NinjsModule.elements(name): name is undefined");
+		   }
+		}
 
-NinjsModule.method('elements', function(elements) {
-	if (is_undefined(elements)) {
-	   if (is_typeof(Object, elements)) {
-	      throw new SyntaxError("NinjsModule.elements(elements): elements is undefined");
-	   }
-	   else if (is_string(elements)) {
-	      throw new SyntaxError("NinjsModule.elements(name): name is undefined");
-	   }
-	}
-	
-	// If first argument is a string, retrieve the element
-	if (is_string(elements)) {
-		var name = elements;
-		return is_defined(this.dom[name]) ? this.dom[name] : undefined;
-	}
-	// Set elements
-	else {
-		this.call_on_ready(function() {
-			for(var key in elements) {
-				if (elements.hasOwnProperty(key)) {
-					this.dom[key] = elements[key];
+		if (is_string(elements)) {
+			var name = elements;
+			return this.dom.cached_selectors[name];
+		}
+		else {
+			var dom = this.dom;
+			dom.ready(function() {
+				for(var key in elements) {
+					if (elements.hasOwnProperty(key)) {
+						dom.cached_selectors[key] = elements[key];
+					}
 				}
-			}
-		});
-	}
-});
+			});
+		}
+	});
 
-NinjsModule.method('set_data', function(key, value) {
-	if (is_undefined(key)) {
-		throw new SyntaxError('NinjsModule.set_data(key, value): key is undefined');
-	}
-	
-	if (is_typeof(String, key) && is_undefined(value)) {
-		throw new SyntaxError('NinjsModule.set_data(key, value): value is undefined');
-	}
+	NinjsModule.method('set_data', function(key, value) {
+		if (is_undefined(key)) {
+			throw new SyntaxError('NinjsModule.set_data(key, value): key is undefined');
+		}
+
+		if (is_typeof(String, key) && is_undefined(value)) {
+			throw new SyntaxError('NinjsModule.set_data(key, value): value is undefined');
+		}
 
-	if (is_typeof(String, key)) {
-		this.data[key] = value;
-	}
-	else if (is_typeof(Object, key)) {
-		var data = key;
-		for(var property in data) {
-			this.data[property] = data[property];
+		if (is_typeof(String, key)) {
+			this.data[key] = value;
+		}
+		else if (is_typeof(Object, key)) {
+			var data = key;
+			for(var property in data) {
+				this.data[property] = data[property];
+			}
 		}
-	}
 
-	return this;
-});
+		return this;
+	});
 
-NinjsModule.method('add_test', function(test_file) {
-	this.tests.push(test_file);
-});
+	NinjsModule.method('add_test', function(test_file) {
+		this.tests.push(test_file);
+	});
 
-NinjsModule.method('_run_tests', function() {
-	var test_template = [];
-	test_template.push('<div class="test-results" title="Test Results">');
-	test_template.push('<h1 id="qunit-header">' + this.name + ' module tests</h1>');
-	test_template.push('<h2 id="qunit-banner"></h2>');
-	test_template.push('<h2 id="qunit-userAgent"></h2>');
-	test_template.push('<ol id="qunit-tests"></ol>');
-	test_template.push('</div>');
+	NinjsModule.method('_run_tests', function() {
+		var test_template = [];
+		test_template.push('<div class="test-results" title="Test Results">');
+		test_template.push('<h1 id="qunit-header">' + this.name + ' module tests</h1>');
+		test_template.push('<h2 id="qunit-banner"></h2>');
+		test_template.push('<h2 id="qunit-userAgent"></h2>');
+		test_template.push('<ol id="qunit-tests"></ol>');
+		test_template.push('</div>');
 
-	var qunit_dependencies = '<script src="' + _.tests_path +'qunit/qunit.js"></script>';
-	$.getScript(_.tests_path + 'qunit/qunit.js');
-	var qunit_styles = '<link rel="stylesheet" href="' + _.tests_path + 'qunit/qunit.css">';
-	$('body').append(qunit_styles);
-	$('body').append(test_template.join("\n"));
+		var qunit_dependencies = '<script src="' + _.tests_path +'qunit/qunit.js"></script>';
+		$.getScript(_.tests_path + 'qunit/qunit.js');
+		var qunit_styles = '<link rel="stylesheet" href="' + _.tests_path + 'qunit/qunit.css">';
+		$('body').append(qunit_styles);
+		$('body').append(test_template.join("\n"));
 
-	this.tests.each(function(test) {
-		$.getScript(_.tests_path + test + '.test.js', function() {
-			var test_results_dialog = $('.test-results');
-			var height = $(window).height() - 200;
-			var width = $(window).width() - 300;
-			try {
-				test_results_dialog.dialog({
-					width: width,
-					height: height,
-					autoOpen: false,
-					buttons: {
-						"Thanks buddy": function() {
-							test_results_dialog.dialog('close');
+		this.tests.each(function(test) {
+			$.getScript(_.tests_path + test + '.test.js', function() {
+				var test_results_dialog = $('.test-results');
+				var height = $(window).height() - 200;
+				var width = $(window).width() - 300;
+				try {
+					test_results_dialog.dialog({
+						width: width,
+						height: height,
+						autoOpen: false,
+						buttons: {
+							"Thanks buddy": function() {
+								test_results_dialog.dialog('close');
+							}
 						}
-					}
-				});
-				var failed = $('.failed');
-				console.log(failed.html());
-				test_results_dialog.dialog('open');
-			}
-			catch(error) {
-				alert("Test harness requires jQueryUI");
-			}
+					});
+					var failed = $('.failed');
+					console.log(failed.html());
+					test_results_dialog.dialog('open');
+				}
+				catch(error) {
+					alert("Test harness requires jQueryUI");
+				}
+			});
 		});
 	});
-});
+	

data/repository/ninjs/core/nin.js

@@ -1,4 +1,7 @@
-/* File: nin.js */
-//= require "extend"
-//= require "module"
-//= require "application"
+(function() {
+	//= require "existence"
+	//= require "extend"
+	//= require "dom"
+	//= require "module"
+	//= require "application"
+})();

data/repository/ninjs/tests/application.test.js

@@ -0,0 +1,24 @@
+var spec = new QSpec("NinjsApplication");
+
+spec.before = function() {
+	this.app = new NinjsApplication('myapp');
+};
+
+spec.after = function() {
+	delete this.app;
+};
+
+spec.should("create a ninjs application object", function() {
+	this.app = new NinjsApplication('myapp');
+	ok(is_defined(this.app), 'app is defined');
+	ok(is_typeof(NinjsApplication, this.app), 'app is a valid NinjsApplication');
+});
+
+spec.should("create a NinjsModule", function() {
+	this.app = new NinjsApplication('myapp');
+	this.app.add_module('mymod');
+
+	ok(is_typeof(NinjsModule, this.app.mymod), 'app.mymod is a valid NinjsModule');
+});
+
+spec.run_all();

data/repository/ninjs/tests/array.utilities.test.js

@@ -0,0 +1,55 @@
+var spec = new QSpec("Array Extensions"); 
+
+spec.should("test for emptiness with is_empty and not_empty", 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");
+});
+
+spec.should("iterate over each element with each", 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');
+});
+
+spec.should("test if 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');
+});
+
+spec.run_all();

data/repository/ninjs/tests/existence.test.js

@@ -0,0 +1,64 @@
+var spec = new QSpec("Existence");
+
+spec.should("test for existence with is_defined", 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');
+});
+
+spec.should("test for non-existence with is_undefined", 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');
+});
+
+spec.should("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');
+});
+
+spec.should("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');
+});
+
+spec.should("determine if a string is 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');
+});
+
+spec.run_all();