diff options
Diffstat (limited to 'js/jquery.mustache.js')
| -rw-r--r-- | js/jquery.mustache.js | 213 |
1 files changed, 213 insertions, 0 deletions
diff --git a/js/jquery.mustache.js b/js/jquery.mustache.js new file mode 100644 index 0000000..fcc47d1 --- /dev/null +++ b/js/jquery.mustache.js @@ -0,0 +1,213 @@ +/*! jQuery Mustache - v0.2.7 - 2013-01-30 +* https://github.com/jonnyreeves/jquery-Mustache +* Copyright (c) 2013 Jonny Reeves; Licensed MIT */ + +/*global jQuery, window */ +(function ($, window) { + 'use strict'; + + var templateMap = {}, + instance = null, + options = { + // Should an error be thrown if an attempt is made to render a non-existent template. If false, the + // operation will fail silently. + warnOnMissingTemplates: false, + + // Should an error be thrown if an attempt is made to overwrite a template which has already been added. + // If true the original template will be overwritten with the new value. + allowOverwrite: true, + + // The 'type' attribute which you use to denoate a Mustache Template in the DOM; eg: + // `<script type="text/html" id="my-template"></script>` + domTemplateType: 'text/html', + + // Specifies the `dataType` attribute used when external templates are loaded. + externalTemplateDataType: 'text' + }; + + function getMustache() { + // Lazily retrieve Mustache from the window global if it hasn't been defined by + // the User. + if (instance === null) { + instance = window.Mustache; + if (instance === void 0) { + $.error("Failed to locate Mustache instance, are you sure it has been loaded?"); + } + } + return instance; + } + + /** + * Returns true if the supplied templateName has been added. + */ + function has(templateName) { + return templateMap[templateName] !== void 0; + } + + /** + * Registers a template so that it can be used by $.Mustache. + * + * @param templateName A name which uniquely identifies this template. + * @param templateHtml The HTML which makes us the template; this will be rendered by Mustache when render() + * is invoked. + * @throws If options.allowOverwrite is false and the templateName has already been registered. + */ + function add(templateName, templateHtml) { + if (!options.allowOverwrite && has(templateName)) { + $.error('TemplateName: ' + templateName + ' is already mapped.'); + return; + } + templateMap[templateName] = $.trim(templateHtml); + } + + /** + * Adds one or more tempaltes from the DOM using either the supplied templateElementIds or by retrieving all script + * tags of the 'domTemplateType'. Templates added in this fashion will be registered with their elementId value. + * + * @param [...templateElementIds] List of element id's present on the DOM which contain templates to be added; + * if none are supplied all script tags that are of the same type as the + * `options.domTemplateType` configuration value will be added. + */ + function addFromDom() { + var templateElementIds; + + // If no args are supplied, all script blocks will be read from the document. + if (arguments.length === 0) { + templateElementIds = $('script[type="' + options.domTemplateType + '"]').map(function () { + return this.id; + }); + } + else { + templateElementIds = $.makeArray(arguments); + } + + $.each(templateElementIds, function() { + var templateElement = document.getElementById(this); + + if (templateElement === null) { + $.error('No such elementId: #' + this); + } + else { + add(this, $(templateElement).html()); + } + }); + } + + /** + * Removes a template, the contents of the removed Template will be returned. + * + * @param templateName The name of the previously registered Mustache template that you wish to remove. + * @returns String which represents the raw content of the template. + */ + function remove(templateName) { + var result = templateMap[templateName]; + delete templateMap[templateName]; + return result; + } + + /** + * Removes all templates and tells Mustache to flush its cache. + */ + function clear() { + templateMap = {}; + getMustache().clearCache(); + } + + /** + * Renders a previously added Mustache template using the supplied templateData object. Note if the supplied + * templateName doesn't exist an empty String will be returned. + */ + function render(templateName, templateData) { + if (!has(templateName)) { + if (options.warnOnMissingTemplates) { + $.error('No template registered for: ' + templateName); + } + return ''; + } + return getMustache().to_html(templateMap[templateName], templateData, templateMap); + } + + /** + * Loads the external Mustache templates located at the supplied URL and registers them for later use. This method + * returns a jQuery Promise and also support an `onComplete` callback. + * + * @param url URL of the external Mustache template file to load. + * @param onComplete Optional callback function which will be invoked when the templates from the supplied URL + * have been loaded and are ready for use. + * @returns jQuery deferred promise which will complete when the templates have been loaded and are + * ready for use. + */ + function load(url, onComplete) { + return $.ajax({ + url: url, + dataType: options.externalTemplateDataType + }).done(function (templates) { + $(templates).filter('script').each(function (i, el) { + add(el.id, $(el).html()); + }); + + if ($.isFunction(onComplete)) { + onComplete(); + } + }); + } + + /** + * Returns an Array of templateNames which have been registered and can be retrieved via + * $.Mustache.render() or $(element).mustache(). + */ + function templates() { + return $.map(templateMap, function (value, key) { + return key; + }); + } + + // Expose the public methods on jQuery.Mustache + $.Mustache = { + options: options, + load: load, + add: add, + addFromDom: addFromDom, + remove: remove, + clear: clear, + render: render, + templates: templates, + instance: instance + }; + + /** + * Renders one or more viewModels into the current jQuery element. + * + * @param templateName The name of the Mustache template you wish to render, Note that the + * template must have been previously loaded and / or added. + * @param templateData One or more JavaScript objects which will be used to render the Mustache + * template. + * @param options.method jQuery method to use when rendering, defaults to 'append'. + */ + $.fn.mustache = function (templateName, templateData, options) { + var settings = $.extend({ + method: 'append' + }, options); + + var renderTemplate = function (obj, viewModel) { + $(obj)[settings.method](render(templateName, viewModel)); + }; + + return this.each(function () { + var element = this; + + // Render a collection of viewModels. + if ($.isArray(templateData)) { + $.each(templateData, function () { + renderTemplate(element, this); + }); + } + + // Render a single viewModel. + else { + renderTemplate(element, templateData); + } + }); + }; + +}(jQuery, window));
\ No newline at end of file |