ninjs 0.9.2 → 0.10.0

data/repository/jquery/ui/latest.js

@@ -0,0 +1 @@
+//= require "1.8.7"

data/repository/ninjs/core/.existence.pdoc.yaml

@@ -0,0 +1,12 @@
+---
+id: "is_defined"
+type: class method
+line_number: 5
+description: |
+
+
+signatures:
+ -
+  signature: ".is_defined(suspect)"
+  return_value: "Any"
+file: /Volumes/Storage/Development/ninjs/repository/ninjs/core/existence.js

data/repository/ninjs/core/application.js

@@ -0,0 +1,43 @@
+/*
+   File: application.js
+   
+   Class: NinjsApplication
+      An NinjsApplication object serves as your application's namespace and includes a utility to add modules to the application object.
+
+   See Also:
+      <NinjsModule>
+*/
+var NinjsApplication = function() {
+	if (is_undefined(window._)) {
+		window._ = this;
+	}
+
+	if (is_undefined(window.app)) {
+		window.app = this;
+	}
+};
+
+/*
+   Method: add_module
+      Adds a NinjsModule to the application.
+   
+   Parameters:
+      name - the name of the module
+      
+   > myapp.add_module('my_module');
+*/
+NinjsApplication.method('add_module', function(name) {
+	try {
+		if (is_undefined(name)) {
+			throw new SyntaxError("NinjsApplication.add_module(name): name is undefined");
+		}
+
+		if (is_defined(this[name])) {
+			throw new SyntaxError("NinjsApplication.add_module(name): '" + name + "' already declared");
+		}
+		this[name] = new NinjsModule(name);
+	}
+	catch(error) {
+		alert(error.message);
+	}
+});

data/repository/ninjs/core/existence.js

@@ -1,26 +1,75 @@
+/* File: existence.js */
 if (is_defined === undefined) {
-	var is_defined = function(variable) {	
-		return (variable === undefined) ? false : true;
+   /*
+      Function: is_defined
+         Checks if a variable is undefined.
+
+      Parameters:
+         suspect - suspect variable to test
+
+      Returns:
+         bool
+
+      See Also:
+
+         <is_undefined>
+   */
+	var is_defined = function(suspect) {	
+		return (suspect === undefined) ? false : true;
 	};
 }
 
 if (!is_defined(is_undefined)) {
-	var is_undefined = function(variable) {
-		return (variable === undefined) ? true : false;
+   /*
+      Function: is_undefined
+         Checks if a variable is defined.
+
+      Parameters:
+         suspect - suspect variable to test
+
+      Returns:
+         bool
+
+      See Also:
+
+         <is_defined>
+   */
+	var is_undefined = function(suspect) {
+		return (suspect === undefined) ? true : false;
 	};
 }
 
 if (is_undefined(is_typeof)) {
-	var is_typeof = function(type, variable) {
+   /*
+      Function: is_typeof
+         Determine an object's type strictly by comparing constructors.
+
+      Parameters:
+         type - The type you expect (ie. String, Number, Array without quotes: is_typeof(String, 'hello'): // true)
+         suspect - The variable to check against type
+
+      Returns:
+         bool
+
+      See Also:
+         <is_numeric>, 
+         <is_string>, 
+         <is_array>, 
+         <is_number>, 
+         <is_date>, 
+         <is_bool>, 
+         <is_regex>
+   */
+	var is_typeof = function(type, suspect) {
 		try {
 			if (is_undefined(type)) {
-				throw new SyntaxError("is_typeof(Type, variable): type is undefined");
+				throw new SyntaxError("is_typeof(Type, suspect): type is undefined");
 			}
-			if (is_undefined(variable)) {
-				throw new SyntaxError("is_typeof(Type, variable): variable is undefined");
+			if (is_undefined(suspect)) {
+				throw new SyntaxError("is_typeof(Type, suspect): suspect is undefined");
 			}
 
-			return (variable.constructor == type) ? true : false;
+			return (suspect.constructor == type) ? true : false;
 		}
 		catch(error) {
 			alert(error.message);
@@ -28,8 +77,21 @@ if (is_undefined(is_typeof)) {
 	};
 }
 
-if (is_undefined(is_mumeric)) {
-	var is_mumeric = function(suspect) {
+if (is_undefined(is_numeric)) {
+   /*
+      Function: is_numeric
+         Determine if the suspect string represents a numeric value.
+
+      Parameters:
+         suspect - variable to check for numeric value
+
+      Returns:
+         bool
+
+      See Also:
+         <is_number>
+   */
+	var is_numeric = function(suspect) {
 		if(is_typeof(Number, suspect)) {
 			return true;
 		}
@@ -39,3 +101,151 @@ if (is_undefined(is_mumeric)) {
 		}
 	};
 }
+
+if (is_undefined(is_string)) {
+   /*
+      Function: is_string
+         Determine the suspect is a String. This is a proxy method for is_typeof(String, suspect).
+
+      Parameters:
+         suspect - supect variable to test
+
+      Returns:
+         bool
+
+      See Also:
+         <is_typeof>, 
+         <is_numeric>, 
+         <is_array>, 
+         <is_number>, 
+         <is_date>, 
+         <is_bool>, 
+         <is_regex>
+   */
+  var is_string = function(suspect) {
+    return is_typeof(String, suspect);
+  };
+}
+
+if (is_undefined(is_array)) {
+   /*
+      Function: is_array
+         Determine if the suspect is an Array. This is a proxy method for is_typeof(Array, suspect).
+
+      Parameters:
+         suspect - suspect variable to test
+
+      Returns:
+         bool
+
+      See Also:
+         <is_typeof>, 
+         <is_numeric>, 
+         <is_string>, 
+         <is_number>, 
+         <is_date>, 
+         <is_bool>, 
+         <is_regex>
+   */
+  var is_array = function(suspect) {
+    return is_typeof(Array, suspect);
+  };
+}
+
+if (is_undefined(is_number)) {
+   /*
+      Function: is_number
+         Determines if the suspect is a Number. This is a proxy method for is_typeof(Number, suspect).
+
+      Parameters:
+         suspect - suspect variable to test
+
+      Returns:
+         bool
+
+      See Also:
+         <is_typeof>, 
+         <is_numeric>, 
+         <is_string>, 
+         <is_array>, 
+         <is_date>, 
+         <is_bool>, 
+         <is_regex>
+   */
+  var is_number = function(suspect) {
+    return is_typeof(Number, suspect);
+  };
+}
+
+if (is_undefined(is_date)) {
+   /*
+      Function: is_date
+         Determines if the suspect is a Date. This is a proxy method for is_typeof(Date, suspect).
+
+      Parameters:
+         suspect - suspect variable to test
+
+      Returns:
+         bool
+
+      See Also:
+         <is_typeof>, 
+         <is_numeric>, 
+         <is_string>, 
+         <is_array>, 
+         <is_number>,  
+         <is_bool>, 
+         <is_regex>
+   */
+  var is_date = function(suspect) {
+    return is_typeof(Date, suspect);
+  };
+}
+
+if (is_undefined(is_bool)) {
+   /*
+      Function: is_bool
+         Determines if the suspect is a Boolean. This is a proxy method for is_typeof(Boolean, suspect).
+
+      Parameters:
+         suspect - suspect variable to test
+
+      Returns:
+         bool
+
+      See Also:
+         <is_typeof>, 
+         <is_numeric>, 
+         <is_string>, 
+         <is_array>, 
+         <is_number>, 
+         <is_regex>
+   */
+  var is_bool = function(suspect) {
+    return is_typeof(Boolean, suspect);
+  };
+}
+
+if (is_undefined(is_regex)) {
+   /*
+      Function: is_regex
+         Determines if the suspect is a RegExp. This is a proxy method for is_typeof(RegExp, suspect).
+
+      Parameters:
+         suspect - suspect variable to test
+
+      Returns:
+         bool
+
+      See Also:
+         <is_typeof>, 
+         <is_numeric>, 
+         <is_string>, 
+         <is_array>, 
+         <is_number>,  
+         <is_bool>
+   */
+  var is_regex = function(suspect) {
+    return is_typeof(RegExp, suspect);
+  };
+}

data/repository/ninjs/core/extend.js

@@ -1,6 +1,24 @@
+/* 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_func())
+
+      Parameters:
+         name - name of the method
+         func - function definition
+
+      Returns:
+         this === Function
+         
+      > String.method('custom_method', function() {
+      >    // define custom_method
+      > });
+      >
+      > "hello".custom_method();
+   */
 	Function.prototype.method = function(name, func) {
 		try {
 			if (is_undefined(name)) {

data/repository/ninjs/core/module.js

@@ -0,0 +1,230 @@
+/*
+   File: module.js
+   
+   Class: NinjsModule
+      A NinjsModule is an object which encapsulates a certain behavior or functionality.
+
+   Parameters:
+      name - the name of the module
+
+   See Also:
+      <NinjsApplication>
+*/
+var NinjsModule = function(name) {
+   /*
+      Variable: data
+         The module's data object
+   */
+	this.data = {};
+	/*
+      Variable: name
+         The module's name (string)
+   */
+	this.name = name;
+	/*
+      Variable: run_tests (beta)
+         Boolean to turn tests on/off
+   */
+	this.run_tests = false;
+	/*
+      Variable: tests (beta)
+         Array of test files to run 
+   */
+	this.tests = [];
+};
+
+/*
+   Method: actions
+      The actions method contains code to be executed when run is called. This method is a placeholder to be overwritten.
+      
+   > MyModule.actions = function() {
+   >  // define actions here
+   >};
+*/
+NinjsModule.method('actions', function() {});
+
+
+/*
+   Method: run
+      Waits for the DOM to load then calls execute.
+      
+   > MyModule.run();
+*/
+NinjsModule.method('run', function() {
+	this.call_on_ready(this.execute);
+});
+
+/*
+   Method: call_on_ready
+      Waits for the DOM to be ready and then executes a callback.
+   
+   Parameters:
+      callback - function to be called when the DOM is ready
+      
+   > MyModule.call_on_ready(function() {
+   >    // some code to execute when the DOM is ready
+   > });
+*/
+NinjsModule.method('call_on_ready', function(callback) {
+	var timer;
+	var module = this;
+
+	function check_ready() {
+		timer = setInterval(is_ready, 13);
+	}
+
+	function is_ready() {
+		if (document && document.getElementsByTagName && document.getElementById && document.body) {
+			clearInterval(timer);
+			timer = null;
+			callback.call(module);
+		}
+	}
+
+	check_ready();
+});
+
+/*
+   Method: execute
+      Wrapper method that set's up the environment and then calls actions.
+   
+   > MyModule.execute();
+*/
+NinjsModule.method('execute', function() {
+	// swap out the __ alias
+	this.old__ = is_defined(window.__) ? window.__ : undefined;
+	window.__ = this;
+	
+	if (this.run_tests) {
+		this._run_tests();
+	}
+	this.actions();
+	
+	// reset the __ alias
+	if(is_defined(this.old__)) {
+		window.__ = this.old__;
+	}
+});
+
+/*
+   Method: elements
+      Method to define module elements.
+      
+   Parameters:
+      callback - function to define a module's elements
+      
+   > MyModule.elements(function() {
+   >    // element definitions go here
+   > });
+*/
+NinjsModule.method('elements', function(callback) {
+	// swap out the __ alias
+	this.old__ = is_defined(window.__) ? window.__ : undefined;
+	window.__ = this;
+	
+	this.call_on_ready(callback);
+	
+ 	// reset the __ alias
+	if(is_defined(this.old__)) {
+		window.__ = this.old__;
+	}
+});
+
+
+/*
+   Method: set_data
+      Adds properties to the module's data object.
+      
+   Parameters:
+      key - string or object (if string = key, if object sets multiple properties)
+      value - value of key if key is string
+      
+   > MyModule.set_data('some_key', 'some_value');
+   > MyModule.data.some_key === 'some_value'
+   
+   > MyModule.set_data({
+   >    'property_one': 'value_one',
+   >    'property_two': 'value_two'
+   > });
+   > MyModule.data.property_one === 'value_one'
+   > MyModule.data.property_two === 'value_two'
+*/
+NinjsModule.method('set_data', function(key, value) {
+	try {
+		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];
+			}
+		}
+
+		return this;
+	}
+	catch(error) {
+		alert(error.message);
+	}
+});
+
+/*
+   Method: add_test
+      Adds a test file to the tests array (beta).
+      
+   Parameters:
+      test_file - File to add to the tests array
+      
+   > MyModule.add_test('mytest.test.js');
+*/
+NinjsModule.method('add_test', function(test_file) {
+	this.tests.push(test_file);
+});
+
+/*
+   Method: run_tests
+      Runs the test files in the test array. This method is automatically called by the execute method if run_tests === true
+*/
+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>');
+
+	$('body').append(test_template.join("\n"));
+
+	this.tests.each(function(test) {
+		$.getScript('tests/' + some + '.test.js', function() {
+			var test_results_dialog = $('.test-results');
+			var height = test_results_dialog.height() + 130;
+			var width = $(window).width() - 300;
+			var maxHeight = $(window).height() - 200;
+			try {
+				test_results_dialog.dialog({
+					width: width,
+					height: height,
+					maxHeight: maxHeight,
+					buttons: {
+						"Thanks buddy": function() {
+							test_results_dialog.dialog('close');
+						}
+					}
+				});
+			}
+			catch(error) {
+				alert("Test harness requires jQueryUI");
+			}
+		});
+	});
+});