raptor/lib/raptor/templating/templating_async.js

RaptorJS provides an AMD module loader that works in Node, Rhino and the web browser. It also includes various sub-modules to support building optimized web applications.

/*
 * Copyright 2011 eBay Software Foundation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
/**
 *
 * @extension Async
 *
 */
define.extend('raptor/templating', function(require) {
    "use strict";
    
    var promises = require('raptor/promises');

    return {
        
        renderToStringAsync: function(templateName, data, context, callback) {
            if (typeof context === 'function') {
                callback = context;
                context = null;
            }

            if (!context) {
                context = this.createContext();
            }

            var promise = this.renderAsync(templateName, data, context);
            var deferred = promises.defer();
            promise
                .then(function() {
                    var str = context.getOutput();
                    if (callback) {
                        callback(null, str);
                    }
                    deferred.resolve(str);
                })
                .fail(function(e) {
                    if (callback) {
                        callback(e);
                    }
                    deferred.reject(e);
                });

            return deferred.promise;
        },

        renderAsync: function(templateName, data, context) {
            if (!context) {
                throw new Error("context is required");
            }

            var deferred = promises.defer();
            
            var attributes = context.attributes;
            var asyncAttributes = attributes.async || (attributes.async = {});
            asyncAttributes.remaining = 0;
            asyncAttributes.deferred = deferred;

            try {
                this.render(templateName, data, context);
            }
            catch(e) {
                deferred.reject(e);
            }

            asyncAttributes.firstPassComplete = true;

            if (asyncAttributes.remaining === 0) {
                deferred.resolve(context);
            }

            return deferred.promise;
        }
    };
});