Add deep resolution of Thenables in context

[sethkinast]

As part of this change, Jasmine has been updated to properly handle async render tests. Before this, any asynchronous test that called dust.render() always passed.

• Updated grunt-contrib-jasmine to use Jasmine 2.0.1 (was 1.3.1)
• Updated Rhino test JAR from 1.7R5-rc1 to 1.7R5-final
• Refactored unit tests for Jasmine 2

Closes #588

[sethkinast]

Reworked the PR into two separate commits so it was easy to see the changes needed to support deep resolution.

[jimmyhchan]

The async commit is awesome. Thanks for that. The deep promise resolution hurts my brains.

Please add a test in case one of the thenable thens (I N C E P T I O N) fails.

As discussed a partial function here would make this easier to grok. The closure to get at currentContext and tracking down down.slice(i)only to realize that it stays as i since you return immediately make go way over my head. (stupid promises and their single return value :) )

Nice to have but not necessary

[sethkinast]

Added a third commit with an explicit closure creation. Let me know if you like that better.

I think I don't like it as well just because it's one extra layer of indirection for me to keep track of in my mental model. I can see how it makes it more explicit, though.

[sethkinast]

Added some new tests, by the way. How sick is this:

      {
        name:     "thenable deep section, traverse outside",
        source:   "Eventually my {#magic.ally}{prince} {delicious}{/magic.ally} will come",
        context:  { "prince": "Prince", "magic": new FalsePromise(null, {"ally": {"delicious": new FalsePromise(null, "Lucky Charms")} }) },
        expected: "Eventually my Prince Lucky Charms will come",
        message: "should reserve an async section for a deep-reference thenable and not blow the stack"
      },

Half of the section key lookup is a promise and the other half isn't.

[jimmyhchan]

Thinking of the possibility for a defer helper or just returning promises from helpers

[sethkinast]

That's what chunk.map and friends are for. All of this is just syntactic sugar.

At Amazon we had a wrapper around chunk.map to make it easier to use that looked something like this:

return async(arguments, function(params, done) {
    // do some async stuff, then eventually
    done(null, { some: "data" }); // pushes onto the context and calls chunk.render for you, etc
});

[sethkinast]

You can definitely return a promise from a helper now, that's maybe 60% the point of this PR and the one before it, so that people can plop externalModule.doSomethingThatReturnsAPromise into their context and it just works.

{
  "user": db.fetchUser
}

vs

{
  "user": function(chunk, context, bodies, params) {
    return chunk.map(function(chunk) {
      db.fetchUser().then(function(data) {
        chunk.render(bodies.block, context.push(data)).end();
      }, function(err) {
        chunk.render(bodies.error, context.push(err)).end();
      });
    });
  }
}