- small refactors

- try/catch on defaultHandler
pblabs · Jun 13, 2011 · 21886d6 · 21886d6
1 parent e3da9d8
commit 21886d6
Show file tree

Hide file tree

Showing 2 changed files with 84 additions and 72 deletions.
diff --git a/zen-http.js b/zen-http.js
@@ -11,12 +11,14 @@ var errorHandler = function error(req, resp, err) {
 			"Content-Type": "text/plain"
 		});
 		resp.end(err.stack + "\n");
+		console.error(err.stack + "\n");
 		return;
 	}
 	resp.writeHead(404, {
 		"Content-Type": "text/plain"
 	});
 	resp.end("Not Found\n");
+	console.log("Not Found\n");
 };
 /**
  * Default result handler
@@ -26,45 +28,48 @@ var resultHandler = function result(req, resp, result) {
 		"Content-Type": "octet/stream"
 	});
 	resp.end(result);
+	console.log("result");
 };
-
-
 /**
  * Zen uses a 'setup' pattern, returning a callable engine function
  */
-module.exports= function (/*layers*/) {
+module.exports= function (/*handlers*/) {
 	/**
 	 * Default handler delegates to the error handler
 	 */
 	var defaultHandler = function(req, resp) {
-		return engine.errorHandler(req, resp);
+		try {
+			return engine.errorHandler(req, resp,undefined); //explicit undef error passing
+		} catch (ex) {
+			return errorHandler(req,resp,ex);
+		}
 	};
-	var layers=Array.prototype.slice.call(arguments).reverse();
-
-	var L=layers.length-1;
-
+	var handlers=Array.prototype.slice.call(arguments).reverse();
+	var L=handlers.length-1;
 	// The real Zen Engine
 	var engine= function (req, resp) {
 		var i=L;
-		try {			
-			var next= function(err,res) {
-				if(!err&&!res) {					
-					if (--i>=0) return layers[i](req,resp,next); 
-				} 
-				if (res) 
-					return engine.resultHandler(req,resp,res)				
+		try {
+			function next (err,res) {
+				if(!res&&!err) {
+					if (--i>=0)
+						return handlers[i](req,resp,next);
+				} else if (res)
+					return engine.resultHandler(req,resp,res)
 				return engine.errorHandler(req,resp,err);
 			}
-			return layers[i](req,resp,next);
+
+			return handlers[i](req,resp,next);
 		} catch (err) {
-			try{
+			try {
 				return engine.errorHandler(req, resp, err);
 			} catch (ex) {
 				return errorHandler(req,resp,ex);
 			}
 		}
 	}
-	if (L<0){engine=defaultHandler}; //default
+	if (L<0)
+		engine=defaultHandler; //default
 	engine.errorHandler = errorHandler;
 	engine.resultHandler = resultHandler;
 	return engine;

diff --git a/zen.js b/zen.js
@@ -1,3 +1,7 @@
+/**
+ * Zen
+ */
+
 /**
  * Default error handler
  */
@@ -16,88 +20,91 @@ var errorHandler = function error(/*args,*/ /*err*/) {
  */
 var resultHandler = function result(/*args,*/ /*res*/) {
 	var res=(arguments.length >0)?arguments[arguments.length-1]:null;
-	if (res) console.log(res);
+	if (res)
+		console.log(res);
 	return;
 };
-
-
 /**
  * Zen uses a 'setup' pattern, returning a callable engine function
  */
-module.exports= function (/*layers*/) {
+module.exports= function (/*handlers*/) {
 	/**
 	 * Default handler delegates to the error handler
 	 */
 	var defaultHandler = function(/*args*/) {
-		var arg= Array.prototype.slice.call(arguments);
-		arg.push(undefined);//err
-		return engine.errorHandler.apply(this,arg);
+		try {
+			var arg= Array.prototype.slice.call(arguments);
+			arg.push(undefined);//err
+			return engine.errorHandler.apply(this,arg);
+		} catch (ex) {
+			var arg= Array.prototype.slice.call(arguments);
+			arg.push(ex);//err
+			return errorHandler.apply(this,arg);
+		}
 	};
-
-	var layers=Array.prototype.slice.call(arguments).reverse();	
-	var L=layers.length-1;
-
+	var handlers=Array.prototype.slice.call(arguments).reverse();
+	var L=handlers.length-1;
 	// The real Zen Engine
 	var engine= function (/*handleArgs*/) {
-		var handleArgs=Array.prototype.slice.call(arguments);
-		var self=this;
 		var i=L;
-
-		//handler optimization
-		var argLength=arguments.length;
 		try {
-			function handle(handler){
+			var handleArgs=Array.prototype.slice.call(arguments);
+			var self=this;
+			//handler optimization
+			var argLength=arguments.length;
+			function handle(handler) {
 				switch (argLength) {
-						// faster 
-						case 0:
-							return handler.call(self, next);
-							break;
-						case 1:
-							return handler.call(self, handleArgs[0],next);
-							break;
-						case 2:
-							return handler.call(self, handleArgs[0],handleArgs[1], next);
-							break;
-						case 3:
-							return handler.call(self, handleArgs[0],handleArgs[1], handleArgs[2],next);							
-							break;
-						case 4:
-							return handler.call(self, handleArgs[0],handleArgs[1], handleArgs[2], handleArgs[3], next);							
-							break;
-							
-						// slower
-						default:
-							var nextedArgs=Array.prototype.slice.call(handleArgs);
-							nextedArgs.push(next)							
-							return handler.apply(self, nextedArgs);
-					}
+					// faster
+					case 0:
+						return handler.call(self, next);
+						break;
+					case 1:
+						return handler.call(self, handleArgs[0],next);
+						break;
+					case 2:
+						return handler.call(self, handleArgs[0],handleArgs[1], next);
+						break;
+					case 3:
+						return handler.call(self, handleArgs[0],handleArgs[1], handleArgs[2],next);
+						break;
+					case 4:
+						return handler.call(self, handleArgs[0],handleArgs[1], handleArgs[2], handleArgs[3], next);
+						break;
+
+					// slower
+					default:
+						var nextedArgs=Array.prototype.slice.call(handleArgs);
+						nextedArgs.push(next)
+						return handler.apply(self, nextedArgs);
+				}
 			}
-						
+
 			function next (err,res) {
-				if(!res&&!err) {					
-					if (--i>=0) return handle(layers[i]);
-				} 
-				if (res) {
+				if(!res&&!err) {
+					if (--i>=0)
+						return handle(handlers[i]);
+				} else if (res) {
 					handleArgs.push(res);
 					return engine.resultHandler.apply(this,handleArgs);
 				}
 				handleArgs.push(err);
-				return engine.errorHandler.apply(this,handleArgs);		
+				return engine.errorHandler.apply(this,handleArgs);
 			}
-														
-			return handle(layers[i]);
+
+			return handle(handlers[i]);
 		} catch (err) {
-			handleArgs.push(err);
-			try{
-			return engine.errorHandler.apply(self,handleArgs);
-			} catch(ex) {
+			try {
+				handleArgs.push(err);
+				return engine.errorHandler.apply(self,handleArgs);
+			} catch (ex) {
 				handleArgs[handleArgs.length-1]=ex;
 				return errorHandler.apply(self,handleArgs);
 			}
 		}
 	}
-	if (L<0){engine=defaultHandler}; //default
+	if (L<0)
+		engine=defaultHandler; //default
 	engine.errorHandler = errorHandler;
 	engine.resultHandler = resultHandler;
 	return engine;
-};
+};