set errors on the chunk when catching errors so that the proper callbacks are invoked...

lib/compiler.js

@@ -19,7 +19,7 @@
     //
     // for the common case (using compile and render) a name is required so that templates will be cached by name and rendered later, by name.
     if (!name && name !== null) {
-      dust.log(new Error("Template name parameter cannot be undefined when calling dust.compile"), 'ERROR');
+      throw new Error('Template name parameter cannot be undefined when calling dust.compile');
     }
 
     try {

lib/dust.js

@@ -13,7 +13,6 @@
       loggerContext;
 
   dust.debugLevel = NONE;
-  dust.silenceErrors = false;
 
   // Try to find the console in global scope
   if (root && root.console && root.console.log) {
@@ -39,7 +38,8 @@
   } : function() { /* no op */ };
 
   /**
-   * If dust.isDebug is true, Log dust debug statements, info statements, warning statements, and errors.
+   * Log dust debug statements, info statements, warning statements, and errors.
+   * Filters out the messages based on the dust.debuglevel.
    * This default implementation will print to the console if it exists.
    * @param {String|Error} message the message to print/throw
    * @param {String} type the severity of the message(ERROR, WARN, INFO, or DEBUG)
@@ -54,31 +54,6 @@
       dust.logQueue.push({message: message, type: type});
       logger.log('[DUST ' + type + ']: ' + message);
     }
-
-    if (!dust.silenceErrors && type === ERROR) {
-      if (typeof message === 'string') {
-        throw new Error(message);
-      } else {
-        throw message;
-      }
-    }
-  };
-
-  /**
-   * If debugging is turned on(dust.isDebug=true) log the error message and throw it.
-   * Otherwise try to keep rendering.  This is useful to fail hard in dev mode, but keep rendering in production.
-   * @param {Error} error the error message to throw
-   * @param {Object} chunk the chunk the error was thrown from
-   * @public
-   */
-  dust.onError = function(error, chunk) {
-    logger.log('[!!!DEPRECATION WARNING!!!]: dust.onError will no longer return a chunk object.');
-    dust.log(error.message || error, ERROR);
-    if(!dust.silenceErrors) {
-      throw error;
-    } else {
-      return chunk;
-    }
   };
 
   dust.helpers = {};
@@ -97,17 +72,18 @@
     try {
       dust.load(name, chunk, Context.wrap(context, name)).end();
     } catch (err) {
-      dust.log(err, ERROR);
+      chunk.setError(err);
     }
   };
 
   dust.stream = function(name, context) {
-    var stream = new Stream();
+    var stream = new Stream(),
+        chunk = stream.head;
     dust.nextTick(function() {
       try {
         dust.load(name, stream.head, Context.wrap(context, name)).end();
       } catch (err) {
-        dust.log(err, ERROR);
+        chunk.setError(err);
       }
     });
     return stream;
@@ -787,7 +763,7 @@
         return chunk;
       }
     } catch (err) {
-      dust.log(err, ERROR);
+      chunk.setError(err);
       return chunk;
     }
   };

test/core.js

@@ -167,7 +167,7 @@ function testRender(unit, source, context, expected, options, baseContext, error
        }
      });
     } catch(err) {
-      unit.equals(err.message, error);
+      unit.equals(err.message || err, error);
     }
     unit.pass();
 };

test/jasmine-test/spec/coreTests.js

@@ -1829,40 +1829,11 @@ var coreTests = [
         message: "test the log messages for an existing not exists check."
       },
       {
-        name: "Errors should be propogated if the silenceErrors flag is not set",
-        source: "{#errorHelper}{/errorHelper}",
-        context: { "errorHelper" : function(chunk, context, bodies, params)
-                   {
-                     dust.debugLevel = 'NONE';
-                     throw new Error('Error should be visible');
-                     return chunk.write('');
-                   }
-                 },
-        error: "Error should be visible",
-        message: "test to make sure errors are not swallowed."
-      },
-      {
-        name: "Errors should not be propogated when the silenceErrors is set to true",
-        source: "Error should NOT be visible{#errorHelper}{/errorHelper}",
-        context: { "error":  {
-                     "errorHelper" : function(chunk, context, bodies, params)
-                     {
-                       dust.debugLevel = 'NONE';
-                       dust.silenceErrors = true;
-                       throw new Error('Error message');
-                       return chunk.write('');
-                     }
-                   }
-                 },
-        expected: "Error should NOT be visible",
-        message: "test to make sure non dust errors are swallowed when the silenceErrors flag is set."
-      },
-      {
-        name: "Errors should be throwable from helpers",
+        name: "Errors should be throwable from helpers and consumed in the render callback/stream onerror",
         source: "{@error errorMessage=\"helper error\"}{/error}",
         context: { },
         error: "helper error",
-        message: "test to make sure errors are properly caught and thrown when thrown from helpers."
+        message: "test to make sure errors are properly caught and propogated to the callbacks."
       }
     ]
   }

test/jasmine-test/spec/renderTestSpec.js

@@ -23,7 +23,11 @@ function render(test) {
       }
       dust.render(test.name, context, function(err, output) {
         var log = dust.logQueue;
-        expect(err).toBeNull();
+        if (test.error) {
+          expect(test.error).toEqual(err.message || err);
+        } else {
+          expect(err).toBeNull();
+        }
         if (test.log) {
           for(var i=0; i<log.length; i++) {
             if(log[i].message === test.log) {
@@ -99,7 +103,8 @@ function stream(test) {
           log = dust.logQueue;
         })
         .on('error', function(err) {
-          output = err.message;
+          flag = true;
+          output = err.message || err;
           log = dust.logQueue;
         })
       } catch(error) {
@@ -193,9 +198,9 @@ function pipe(test) {
           },
           error: function (err) {
             flag = true;
-            output = err.message;
+            output = err.message || err;
             log = dust.logQueue;
-          }
+          } 
         });
         // Pipe to a second stream to test multiple event-listeners
         tpl.pipe({
@@ -209,7 +214,7 @@ function pipe(test) {
           },
           error: function (err) {
             flagTwo = true;
-            outputTwo = err.message;
+            outputTwo = err.message || err;
             logTwo = logTwo.concat(dust.logQueue);
           }
         });