Added namespacing adding to global namespace

Author: David Luecke

examples/monsters.js

@@ -1,6 +1,6 @@
 var Class = require('../lib/class').Class;
 
-var Monster = Class.extend(
+Class.extend('Monster',
 /* @static */
 {
 	count : 0
@@ -41,7 +41,7 @@ console.log("Hydra health: " + hydra.health); // -> 12
 dragon.fight();
 console.log("Dragon health: " + dragon.health); // -> 8
 
-var SeaMonster = Monster.extend(
+Monster.extend('SeaMonster',
 {
 	eat : function(smallChildren)
 	{

examples/response_handler.js

@@ -1,6 +1,6 @@
 var Class = require('../lib/class').Class;
 
-var ResponseHandler = Class.extend({
+Class.extend('Server.Response.Handler', {
 	/* Static */
 }, {
 	init : function(content, headers)
@@ -22,7 +22,7 @@ var ResponseHandler = Class.extend({
 	}
 });
 
-var handler = new ResponseHandler('Hello World from ResponseHandler\n', { 'Content-Type': 'text/plain' });
+var handler = new Server.Response.Handler('Hello World from ResponseHandler\n', { 'Content-Type': 'text/plain' });
 
 var http = require('http');
 http.createServer(handler.callback('handle')).listen(1337, "127.0.0.1");

examples/server.js

@@ -1,6 +1,6 @@
 var cls = require('../lib/class');
 
-var Server = cls.Class.extend({
+cls.extend('Server', {
 	/* Static */
 }, {
 	/* Prototype */

lib/class.js

@@ -126,65 +126,94 @@ util.extend(
 			return inst;
 		},
 
-		extend: function(klass, proto ) {
+		getObject : util.getObject,
+		
+		extend: function( fullName, klass, proto ) {
 			// figure out what was passed
+			if ( typeof fullName != 'string' ) {
+				proto = klass;
+				klass = fullName;
+				fullName = null;
+			}
 			if (!proto ) {
 				proto = klass;
 				klass = null;
 			}
-	
+
 			proto = proto || {};
-			var _super_class = this, _super = this.prototype, prototype;
-	
+			var _super_class = this,
+				_super = this.prototype,
+				name, shortName, namespace, prototype;
+
 			// Instantiate a base class (but only create the instance,
 			// don't run the init constructor)
 			initializing = true;
 			prototype = new this();
 			initializing = false;
 			// Copy the properties over onto the new prototype
 			inheritProps(proto, _super, prototype);
-	
+
 			// The dummy class constructor
-	
+
 			function Class() {
 				// All construction is actually done in the init method
 				if ( initializing ) return;
-	
+
 				if ( this.constructor !== Class && arguments.length ) { //we are being called w/o new
 					return arguments.callee.extend.apply(arguments.callee, arguments);
 				} else { //we are being called w/ new
 					return this.Class.newInstance.apply(this.Class, arguments);
 				}
 			}
-			
 			// Copy old stuff onto class
 			for ( name in this ) {
-				if ( this.hasOwnProperty(name) && ['prototype', 'defaults'].indexOf(name) == -1 ) {
+				if ( this.hasOwnProperty(name) && ['prototype', 'defaults', 'getObject'].indexOf(name) == -1 ) {
 					Class[name] = this[name];
 				}
 			}
-	
+
 			// do static inheritance
 			inheritProps(klass, this, Class);
-	
+
+			// do namespace stuff
+			if ( fullName ) {
+				var parts = fullName.split(/\./),
+					shortName = parts.pop(),
+					current = clss.getObject(parts.join('.'), global, true),
+					namespace = current;
+
+				if(current[shortName]){
+					steal.dev.warn("class.js There's already something called "+fullName);
+				}
+
+				current[shortName] = Class;
+			}
+
 			// set things that can't be overwritten
 			util.extend(Class, {
 				prototype: prototype,
-				constructor: Class
+				namespace: namespace,
+				shortName: shortName,
+				constructor: Class,
+				fullName: fullName
 			});
-	
+
 			//make sure our prototype looks nice
 			Class.prototype.Class = Class.prototype.constructor = Class;
-	
+
 			var args = Class.setup.apply(Class, concatArgs([_super_class],arguments));
-	
+
 			if ( Class.init ) {
 				Class.init.apply(Class, args || []);
 			}
-	
+
 			/* @Prototype*/
 			return Class;
 		}
 	});
 
-clss.prototype.callback = clss.callback;
+clss.prototype.callback = clss.callback;
+exports.extend = function(name, klass, proto)
+{
+	return clss.extend(name, klass, proto);
+};

lib/util.js

@@ -29,7 +29,8 @@ var makeArray = exports.makeArray = function(array, results)
 	if (array != null)
 	{
 		var type = typeof array;
-		if ( array.length == null || type === "string" || type === "function" || type === "regexp")
+		if (array.length == null || type === "string" || type === "function"
+				|| type === "regexp")
 		{
 			ret.push(array);
 		} else
@@ -73,8 +74,7 @@ var isPlainObject = exports.isPlainObject = function(obj)
 	var has_is_property_of_method = hasOwnProperty.call(
 			obj.constructor.prototype, "isPrototypeOf");
 	// Not own constructor property must be Object
-	if (obj.constructor && !has_own_constructor
-			&& !has_is_property_of_method)
+	if (obj.constructor && !has_own_constructor && !has_is_property_of_method)
 	{
 		return false;
 	}
@@ -153,4 +153,55 @@ var extend = exports.extend = function()
 
 	// Return the modified object
 	return target;
+};
+
+var getObject = exports.getObject = function(objectName, roots, add)
+{
+	var isContainer = function(current)
+	{
+		var type = typeof current;
+		return type && (type == 'function' || type == 'object');
+	}, regs =
+	{
+		undHash : /_|-/,
+		colons : /::/,
+		words : /([A-Z]+)([A-Z][a-z])/g,
+		lowUp : /([a-z\d])([A-Z])/g,
+		dash : /([a-z\d])([A-Z])/g,
+		replacer : /\{([^\}]+)\}/g,
+		dot : /\./
+	}, getNext = function(current, nextPart, add){
+		return current[nextPart] || ( add && (current[nextPart] = {}) );
+	};
+
+	var parts = objectName ? objectName.split(regs.dot) : [], length = parts.length, currents = isArray(roots) ? roots
+			: [ roots || globals ], current, ret, i, c = 0, type;
+
+	if (length == 0)
+	{
+		return currents[0];
+	}
+	while (current = currents[c++])
+	{
+		for (i = 0; i < length - 1 && isContainer(current); i++)
+		{
+			current = getNext(current, parts[i], add);
+		}
+		if (isContainer(current))
+		{
+
+			ret = getNext(current, parts[i], add);
+
+			if (ret !== undefined)
+			{
+
+				if (add === false)
+				{
+					delete current[parts[i]];
+				}
+				return ret;
+
+			}
+		}
+	}
 };

test/class.test.js

@@ -1,10 +1,10 @@
-var Class = require('../lib/class').Class;
+var Class = require('../lib/class');
 
 /**
  * Tests creating a simple class
  */
 exports.Simple = function (test) {
-	var Animal = Class.extend({}, {
+	Class.extend("Test.Animal", {}, {
 		doSomething : function()
 		{
 			return this.somethingElse() + ' done';	
@@ -16,15 +16,19 @@ exports.Simple = function (test) {
 		}
 	});
 
-	test.equals(new Animal().doSomething(), 'doing done', "Prototype method call should return this string");
+	var myanimal = new Test.Animal();
+	test.equals(myanimal.doSomething(), 'doing done', "Prototype method call should return this string");
+	test.equals(myanimal.Class.shortName, "Animal", "Testing introspection shortname");
+	test.equals(myanimal.Class.fullName, "Test.Animal", "Testing introspection fullname");
+	test.ok(myanimal.Class.namespace.Animal, "Testing introspection namespace");
 	test.done();
 };
 
 /**
  * Tests the class constructor and setting of instance properties.
  */
 exports.Constructor = function (test) {
-	var Test = Class.extend({}, {
+	Class.extend("Test.Person", {}, {
 		init : function(age)
 		{
 			this._age = age;
@@ -36,31 +40,31 @@ exports.Constructor = function (test) {
 		}
 	});
 
-	test.equals(new Test(23).doSomething(), 23, "Instance property should be set properly");
+	test.equals(new Test.Person(23).doSomething(), 23, "Instance property should be set properly");
 	test.done();
 };
 
 /**
  * Tests extending an existing class
  */
 exports.Extend = function (test) {
-	var Animal = Class.extend({}, {
+	Class.extend("Test.Mammal", {}, {
 		doSomething : function()
 		{
 			return 'done';	
 		}
 	});
 
-	test.equals(new Animal().doSomething(), 'done', "Prototype method call should return this string");
+	test.equals(new Test.Mammal().doSomething(), 'done', "Prototype method call should return this string");
 
-	var Dog = Animal.extend({}, {
+	Test.Mammal.extend("Test.Dog", {}, {
 		doSomething : function()
 		{
 			var oldresult = this._super();
 			return 'bark ' + oldresult;
 		}
 	});
-	test.equals(new Dog().doSomething(), 'bark done', "Extended class should return different string");
+	test.equals(new Test.Dog().doSomething(), 'bark done', "Extended class should return different string");
 
 	test.done();
 };
@@ -69,7 +73,7 @@ exports.Extend = function (test) {
  * Tests accessing static properties
  */
 exports.Static = function (test) {
-	var Test = Class.extend({
+	Class.extend("Test.Static", {
 		staticProperty : 'test',
 		staticMethod : function()
 		{
@@ -82,8 +86,8 @@ exports.Static = function (test) {
 		}
 	});
 
-	test.equals(Test.staticProperty, 'test', "Static properties are always accessible");
-	test.equals(new Test().doSomething(), 'test static', "Static properties should be available");
+	test.equals(Test.Static.staticProperty, 'test', "Static properties are always accessible");
+	test.equals(new Test.Static().doSomething(), 'test static', "Static properties should be available");
 
 	test.done();
 };
@@ -92,7 +96,7 @@ exports.Static = function (test) {
  * Tests the setup() function and currying the return value to the constructor 
  */
 exports.Setup = function (test) {
-	var Test = Class.extend({
+	Class.extend("Test.Setup", {
 	}, {
 		setup : function(arg)
 		{
@@ -105,7 +109,7 @@ exports.Setup = function (test) {
 			this._wrapped = arg;
 		}
 	});
-	test.equals(new Test('test')._wrapped, 'wrapped(test)', "setup() wraps arguments before calling init");
+	test.equals(new Test.Setup('test')._wrapped, 'wrapped(test)', "setup() wraps arguments before calling init");
 
 	test.done();
 };
@@ -114,7 +118,7 @@ exports.Setup = function (test) {
  * Tests callback creation
  */
 exports.Callback = function (test) {
-	var Test = Class.extend({
+	Class.extend("Test.Callback", {
 	}, {
 		init : function()
 		{
@@ -127,7 +131,7 @@ exports.Callback = function (test) {
 			return this._property + value;
 		}
 	});
-	var tester = new Test();
+	var tester = new Test.Callback();
 
 	var callback = tester.callback('doSomething');
 	test.equals(callback(), 'local', "Callback wrapped function should have access to object properties");
@@ -145,7 +149,7 @@ exports.Callback = function (test) {
  * Tests nesting of callback
  */
 exports.CallbackNesting = function (test) {
-	var Test = Class.extend({
+	Class.extend("Test.CallbackNested", {
 	}, {
 		processor : function(arg)
 		{
@@ -157,7 +161,7 @@ exports.CallbackNesting = function (test) {
 			return arg + ' done';
 		}
 	});
-	var tester = new Test();
+	var tester = new Test.CallbackNested();
 	var callback = tester.callback(['processor', 'doSomething']);
 	test.equals(callback('first'), 'first processed done', "Calbacks can be chained and get their previous callbacks result");
 	test.done();

test/util.test.js

@@ -1,5 +1,14 @@
 var util = require('../lib/util');
 
+exports.getObject = function (test) {
+	var obj = {};
+	util.getObject("My.Test.Object", obj, true);
+	test.ok(obj.My, "First level object created");
+	test.ok(obj.My.Test, "Second level object created");
+	test.ok(obj.My.Test.Object, "Third level object created");
+	test.done();
+};
+
 exports.merge = function (test) {
 	var first = [1, 2];
 	var second = [3, 4, 5];