File: handlebars/js/yui-handlebars-compiler-after.js

            // This file contains YUI-specific wrapper code and overrides for the
            // handlebars-compiler module.
            
            /**
            Handlebars parser and compiler. Use this module when you need to compile
            Handlebars templates.
            
            @module handlebars
            @submodule handlebars-compiler
            */
            
            var levels = ['debug', 'info', 'warn', 'error'];
            
            /**
            Logs a debugging message. Note that messages will only be logged when the
            handlebars module is loaded in "debug" mode.
            
            @method log
            @param {String} level Log level for this message. Supported levels are "debug",
                "info", "warn", and "error".
            @param {String} message Message to log.
            @for Handlebars
            */
            Handlebars.logger.log = function (level, message) {
                Y.log(message, levels[level] || 'error', 'Handlebars');
            };
            
            /**
            Compiles and renders a Handlebars template string in a single step.
            
            If you'll be using a template more than once, it's more efficient to compile it
            into a function once using `compile()`, and then render it whenever you need to
            by simply executing the compiled function. However, if you only need to compile
            and render a template once, `render()` is a handy shortcut for doing both in a
            single step.
            
            @example
            
                Y.Handlebars.render('The pie of the day is {{pie}}!', {
                    pie: 'Maple Custard'
                });
                // => "The pie of the day is Maple Custard!"
            
            @method render
            @param {String} string Handlebars template string to render.
            @param {Object} context Context object to pass to the template.
            @param {Object} [options] Compile/render options.
                @param {Object} [options.helpers] Helper functions.
                @param {Object} [options.partials] Partials.
                @param {Object} [options.data] Data.
            @return {String} Rendered template string.
            */
            Handlebars.render = function (string, context, options) {
                return this.compile(string)(context, options);
            };
            
            // The rest of this file is just API docs for methods defined in Handlebars
            // itself.
            
            /**
            Compiles a Handlebars template string into a function. To render the template,
            call the function and pass in a context object.
            
            @example
            
                var template = Y.Handlebars.compile('The pie of the day is {{pie}}!.');
                template({pie: 'Pecan'});
                // => "The pie of the day is Pecan!"
            
            @method compile
            @param {String} string Handlebars template string to compile.
            @param {Object} [options] Compiler options.
            @return {Function} Compiled template function.
            */
            
            /**
            Precompiles a Handlebars template string into a string of JavaScript code. This
            can be used to precompile a template at build time or on the server, and the
            resulting template can then be rendered at runtime or on the client without
            needing to go through a compile step.
            
            To render a precompiled template, evaluate the code and then pass the resulting
            function to `Y.Handlebars.template()` to get back an executable template
            function.
            
            @method precompile
            @param {String} string Handlebars template string to compile.
            @param {Object} [options] Compiler options.
            @return {String} Precompiled template code.
            */