Add context.clone and context.pop

lib/dust.js

@@ -218,6 +218,25 @@
     return (!value);
   };
 
+  dust.isEmptyObject = function(obj) {
+    var key;
+    if (obj === null) {
+      return false;
+    }
+    if (obj === undefined) {
+      return false;
+    }
+    if (obj.length > 0) {
+      return false;
+    }
+    for (key in obj) {
+      if (Object.prototype.hasOwnProperty.call(obj, key)) {
+        return false;
+      }
+    }
+    return true;
+  };
+
   // apply the filter chain and return the output string
   dust.filter = function(string, auto, filters) {
     if (filters) {
@@ -308,7 +327,7 @@
    * @return {string | object}
    */
   Context.prototype._get = function(cur, down) {
-    var ctx = this.stack,
+    var ctx = this.stack || {},
         i = 1,
         value, first, len, ctxThis, fn;
     first = down[0];
@@ -381,12 +400,24 @@
     return new Context(new Stack(head, this.stack, idx, len), this.global, this.blocks, this.getTemplateName());
   };
 
+  Context.prototype.pop = function() {
+    var head = this.current();
+    this.stack = this.stack && this.stack.tail;
+    return head;
+  };
+
   Context.prototype.rebase = function(head) {
     return new Context(new Stack(head), this.global, this.blocks, this.getTemplateName());
   };
 
+  Context.prototype.clone = function() {
+    var context = this.rebase();
+    context.stack = this.stack;
+    return context;
+  };
+
   Context.prototype.current = function() {
-    return this.stack.head;
+    return this.stack && this.stack.head;
   };
 
   Context.prototype.getBlock = function(key, chk, ctx) {
@@ -743,37 +774,26 @@
   };
 
   Chunk.prototype.partial = function(elem, context, params) {
-    var partialContext;
-    //put the params context second to match what section does. {.} matches the current context without parameters
-    // start with an empty context
-    partialContext = dust.makeBase(context.global);
-    partialContext.blocks = context.blocks;
-    if (context.stack && context.stack.tail){
-      // grab the stack(tail) off of the previous context if we have it
-      partialContext.stack = context.stack.tail;
-    }
-    if (params){
-      //put params on
-      partialContext = partialContext.push(params);
-    }
+    var head;
 
-    if(typeof elem === 'string') {
-      partialContext.templateName = elem;
+    if (!dust.isEmptyObject(params)) {
+      context = context.clone();
+      head = context.pop();
+      context = context.push(params)
+                       .push(head);
     }
 
-    //reattach the head
-    partialContext = partialContext.push(context.stack.head);
-
-    var partialChunk;
-    if (typeof elem === 'function') {
-      partialChunk = this.capture(elem, partialContext, function(name, chunk) {
-        partialContext.templateName = partialContext.templateName || name;
-        dust.load(name, chunk, partialContext).end();
+    if (elem.__dustBody) {
+      // The eventual result of evaluating `elem` is a partial name
+      // Load the partial after getting its name and end the async chunk
+      return this.capture(elem, context, function(name, chunk) {
+        context.templateName = name;
+        dust.load(name, chunk, context).end();
       });
     } else {
-      partialChunk = dust.load(elem, this, partialContext);
+      context.templateName = elem;
+      return dust.load(elem, this, context);
     }
-    return partialChunk;
   };
 
   Chunk.prototype.helper = function(name, context, bodies, params) {

test/jasmine-test/spec/coreTests.js

@@ -1056,11 +1056,18 @@ var coreTests = [
     tests : [
       {
         name:     "partials",
-        source:   '{>partial/} {>"hello_world"/} {>"{ref}"/}',
+        source:   '{>partial foo=0 /} {>"hello_world" foo=1 /} {>"{ref}" foo=2 /}',
         context:  { name: "Jim", count: 42, ref: "hello_world" },
         expected: "Hello Jim! You have 42 new messages. Hello World! Hello World!",
         message:  "should test partials"
       },
+	  {
+		name:	  "partial with async ref as name",
+		source:   '{>"{ref}" /}',
+		context:  { ref: function(chunk, context) { return chunk.map(function(chunk) { setTimeout(function() { chunk.end('hello_world'); }) }); }},
+		expected: "Hello World!",
+		message:  "should test partial with an asynchronously-resolved template name"
+	  },
       {
         name:     "partial with context",
         source:   "{>partial:.profile/}",

test/jasmine-test/spec/renderTestSpec.js

@@ -28,7 +28,9 @@ function render(test) {
           err = err.message || err;
           expect(err).toContain(test.error);
         } else {
-          expect(err).toBeNull();
+          if(err) {
+            expect(err.message).toBeNull();
+          }
         }
         if (test.log) {
           for(var i=0; i<log.length; i++) {