ninjs-framework 0.1.0

data/spec/tmp/application/test.js

@@ -0,0 +1,14 @@
+(function(app) {
+  var m = app.add_module('test');
+  m.set_data({
+    some_prop: 'some value'
+  });
+  m.elements({
+    test: $('.foo');
+  });
+  m.actions = function() {
+
+  };
+
+  m.run();
+})();

data/spec/tmp/elements/test.elements.js

@@ -0,0 +1,3 @@
+  m.elements({
+    test: $('.foo');
+  });

data/spec/tmp/lib/nin.js

@@ -0,0 +1,297 @@
+is_defined = function(suspect) {
+	return ((suspect === undefined) || (suspect === null)) ? false : true;
+};
+
+is_undefined = function(suspect) {
+	return (suspect === undefined) ? true : false;
+};
+
+is_typeof = function(type, suspect) {
+	if (is_undefined(type)) {
+		throw new SyntaxError("is_typeof(Type, suspect): type is undefined");
+	}
+	if (is_undefined(suspect)) {
+		throw new SyntaxError("is_typeof(Type, suspect): suspect is undefined");
+	}
+
+	return (suspect.constructor == type) ? true : false;
+};
+
+is_numeric = function(suspect) {
+	if(is_typeof(Number, suspect)) {
+		return true;
+	}
+	else {
+		var pattern = /^-?\d+(?:\.\d*)?(?:e[+\-]?\d+)?$/i;
+		return pattern.test(suspect);
+	}
+};
+
+is_string = function(suspect) {
+	return is_typeof(String, suspect);
+};
+
+is_array = function(suspect) {
+	return is_typeof(Array, suspect);
+};
+
+is_number = function(suspect) {
+	return is_typeof(Number, suspect);
+};
+
+is_date = function(suspect) {
+	return is_typeof(Date, suspect);
+};
+
+is_bool = function(suspect) {
+	return is_typeof(Boolean, suspect);
+};
+
+is_regex = function(suspect) {
+	return is_typeof(RegExp, suspect);
+};
+
+is_empty = function(suspect) {
+	return suspect.length === 0;
+};
+
+is_not_empty = function(suspect) {
+	return suspect.length >= 1;
+};
+unless = function(expression, callback, fallback) {
+	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);
+		}
+	}
+};
+var DomReady = window.DomReady = {},
+    userAgent = navigator.userAgent.toLowerCase(),
+    browser = {
+      version: (userAgent.match( /.+(?:rv|it|ra|ie)[\/: ]([\d.]+)/ ) || [])[1],
+      safari: /webkit/.test(userAgent),
+      opera: /opera/.test(userAgent),
+      msie: (/msie/.test(userAgent)) && (!/opera/.test( userAgent )),
+      mozilla: (/mozilla/.test(userAgent)) && (!/(compatible|webkit)/.test(userAgent))
+    },
+    readyBound = false,
+    isReady = false,
+    readyList = [];
+
+
+function domReady() {
+  if(!isReady) {
+    isReady = true;
+
+    if(readyList) {
+      var length = readyList.length;
+      for(var fn = 0; fn < length; fn++) {
+        readyList[fn].call(window, []);
+      }
+
+      readyList = [];
+    }
+  }
+};
+
+function addLoadEvent(func) {
+  var oldonload = window.onload;
+  if (typeof window.onload != 'function') {
+    window.onload = func;
+  }
+  else {
+    window.onload = function() {
+      if (oldonload) {
+        oldonload();
+      }
+      func();
+    }
+  }
+};
+
+function bindReady() {
+  if(readyBound) {
+    return;
+  }
+
+  readyBound = true;
+
+  if (document.addEventListener && !browser.opera) {
+    document.addEventListener("DOMContentLoaded", domReady, false);
+  }
+
+  if (browser.msie && window == top) (function() {
+    if (isReady) return;
+    try {
+      document.documentElement.doScroll("left");
+    }
+    catch(error) {
+      setTimeout(arguments.callee, 0);
+      return;
+    }
+    domReady();
+  })();
+
+  if(browser.opera) {
+    document.addEventListener( "DOMContentLoaded", function () {
+      if (isReady) return;
+      for (var i = 0; i < document.styleSheets.length; i++)
+      if (document.styleSheets[i].disabled) {
+        setTimeout( arguments.callee, 0 );
+        return;
+      }
+      domReady();
+    }, false);
+  }
+
+  if(browser.safari) {
+    var numStyles;
+    (function(){
+      if (isReady) return;
+
+      if (document.readyState != "loaded" && document.readyState != "complete") {
+        setTimeout( arguments.callee, 0 );
+        return;
+      }
+
+      if (numStyles === undefined) {
+        var links = document.getElementsByTagName("link");
+        for (var i=0; i < links.length; i++) {
+          if(links[i].getAttribute('rel') == 'stylesheet') {
+            numStyles++;
+          }
+        }
+
+        var styles = document.getElementsByTagName("style");
+        numStyles += styles.length;
+      }
+
+      if (document.styleSheets.length != numStyles) {
+        setTimeout( arguments.callee, 0 );
+        return;
+      }
+
+      domReady();
+    })();
+  }
+
+  addLoadEvent(domReady);
+};
+
+DomReady.ready = function(fn, args) {
+  bindReady();
+
+  if (isReady) {
+    fn.call(window, []);
+  }
+  else {
+    readyList.push( function() { return fn.call(window, []); } );
+  }
+};
+
+NinjsDOM = function() {
+	this.cached_selectors = {};
+};
+
+NinjsDOM.prototype.ready = function(fn, args) {
+	bindReady();
+
+	if (isReady) {
+		fn.call(window, args || []);
+	}
+	else {
+		readyList.push( function() { return fn.call(window, args || []); } );
+	}
+};
+
+bindReady();
+NinjsModule = function(name) {
+	this.dom = new NinjsDOM(this);
+	this.data = {};
+	this.name = name;
+};
+
+NinjsModule.prototype.actions = function() {};
+
+NinjsModule.prototype.run = function() {
+	var mod = this;
+	this.dom.ready(function() {
+		mod.execute();
+	});
+};
+
+NinjsModule.prototype.execute = function() {
+	this.actions();
+};
+
+NinjsModule.prototype.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 (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.prototype.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];
+		}
+	}
+
+	return this;
+};
+NinjsApplication = function() {};
+
+NinjsApplication.prototype.add_module = function(name) {
+	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");
+	}
+
+	if (this.name === name) {
+		throw new SyntaxError("NinjsApplication.add_module(name): a module cannot have the same name as the application");
+	}
+
+	return this[name] = new NinjsModule(name);
+};

data/spec/tmp/lib/utilities.js

@@ -0,0 +1,211 @@
+Array.prototype.is_empty = function() {
+	return is_empty(this);
+};
+
+Array.prototype.not_empty = function() {
+	return is_not_empty(this);
+};
+
+Array.prototype.each = function(callback) {
+	if(is_undefined(callback)) {
+		throw new SyntaxError("Array.each(callback): callback is undefined");
+	}
+
+	for (var i = 0; i < this.length; i++) {
+		var args = [this[i], i];
+		callback.apply(this, args);
+	}
+};
+
+Array.prototype.contains = function(suspect) {
+	var matches = [];
+	this.each(function(value, index) {
+		if(value === suspect) {
+			matches.push(index);
+		}
+	});
+
+	return matches.not_empty() ? matches : false;
+};
+String.prototype.is_empty = function() {
+	return (this.length < 1) ? true : false;
+};
+
+String.prototype.not_empty = function() {
+	return (this.length < 1) ? false : true;
+};
+
+String.prototype.is_numeric = function() {
+	var pattern = /^(\.|-)?\d+(?:\.\d*)?(?:e[+\-]?\d+)?$/i;
+	return pattern.test(this);
+};
+
+String.prototype.trim = function() {
+	return this.replace(/^\s+|\s+$/g, "");
+};
+
+String.prototype.ltrim = function() {
+	return this.replace(/^\s+/,"");
+};
+
+String.prototype.rtrim = function() {
+	return this.replace(/\s+$/,"");
+};
+
+String.prototype.each = function(callback) {
+	if(is_undefined(callback)) {
+		throw new SyntaxError("String.each(callback): callback is undefined");
+	}
+
+	for (var i = 0; i < this.length; i++) {
+		var args = [this.charAt(i), i];
+		callback.apply(this, args);
+	}
+};
+
+String.prototype.capitalize = function() {
+	return this.substr(0, 1).toUpperCase() + this.substr(1);
+};
+
+String.prototype.reverse = function() {
+	return this.split('').reverse().join('');
+};
+
+String.prototype.to_n = function() {
+	return parseFloat(this);
+};
+
+String.prototype.pluck = function(needle) {
+	var pattern = new RegExp(needle, 'g');
+	return this.replace(pattern, '');
+};
+
+String.prototype.single_space = function() {
+	var no_hard_spaces = this.replace(/\&nbsp\;/g, ' ');
+	return no_hard_spaces.replace(/\s+/g, ' ');
+};
+
+String.prototype.compress = function() {
+	return this.replace(/\s+/g, '');
+};
+Number.prototype.to_hex = function() {
+	if (this === 0) {
+		return "00";
+	}
+
+	var chars = "0123456789ABCDEF";
+	var n = Math.max(0, this);
+	n = Math.min(n, 255);
+	n = Math.round(n);
+	return chars.charAt((n - n % 16)/16) + chars.charAt(n % 16);
+};
+var CSS = function() {};
+
+CSS.rgb2hex = function(r,g,b) {
+	pattern = /(\d{1,3})\,\s?(\d{1,3})\,\s?(\d{1,3})/gi;
+	var rgb;
+	if (is_typeof(String, r)) {
+		rgb = r.match(pattern);
+		rgb = rgb[0].split(',');
+	}
+	else {
+		rgb = false;
+	}
+
+	if (rgb) {
+		r = parseInt(rgb[0], 10);
+		g = parseInt(rgb[1], 10);
+		b = parseInt(rgb[2], 10);
+	}
+	else {
+		r = parseInt(r, 10);
+		g = parseInt(g, 10);
+		b = parseInt(b, 10);
+	}
+	return '#' + r.to_hex() + g.to_hex() + b.to_hex();
+};
+
+CSS.hex2rgb = function(hex) {
+	hex = hex.replace('#', '');
+
+	var rgb = [];
+
+	rgb[0] = parseInt(hex.substring(0,2), 16);
+	rgb[1] = parseInt(hex.substring(2,4), 16);
+	rgb[2] = parseInt(hex.substring(4,6), 16);
+
+	rgb.red = rgb[0];
+	rgb.green = rgb[1];
+	rgb.blue = rgb[2];
+
+	rgb.to_s = function() {
+		return 'rgb(' + rgb.red +', ' + rgb.green + ', ' + rgb.blue + ')';
+	};
+
+	rgb.each = function(callback) {
+		for (var i = 0; i < 3; i++) {
+			callback.call(this, rgb[i]);
+		}
+	};
+
+	return rgb;
+};
+var Cookie = function(name, data, exp) {
+	if (is_undefined(name)) {
+		throw new SyntaxError('new Cookie(name, data[, exp]): name is undefined');
+	}
+
+	function set_exp(days) {
+		var date = new Date();
+		date.setTime(date.getTime() + (days * 24 * 60 * 60 * 1000));
+		var expires = "; expires=" + date.toGMTString();
+	}
+
+	this.name = name;
+
+	unless(this.read(), function() {
+		if (is_undefined(data)) {
+			this.data = '';
+		}
+		else {
+			this.data = data;
+		}
+
+		if (is_defined(days)) {
+			this.exp = set_exp(days);
+		}
+		else {
+			this.exp = '';
+		}
+	});
+
+	this.save();
+};
+
+Cookie.prototype.save = function() {
+	document.cookie = this.name + "=" + this.data + this.exp + "; path=/";
+};
+
+Cookie.prototype.read = function() {
+	var nameEQ = this.name + "=";
+	var ca = document.cookie.split(';');
+	var length = ca.length;
+
+	for (var i = 0; i < length; i++) {
+		var c = ca[i];
+		while (c.charAt(0) == ' ') {
+			c = c.substring(1, c.length);
+		}
+		if (c.indexOf(nameEQ) === 0) {
+			return c.substring(nameEQ.length,c.length);
+		}
+	}
+
+	return null;
+};
+
+Cookie.prototype.remove = function() {
+	this.data = '';
+	this.exp = -1;
+	this.save();
+};