--- a/busui/owa/modules/base/js/includes/jquery/jQote2/external/jquery.mustache.js +++ b/busui/owa/modules/base/js/includes/jquery/jQote2/external/jquery.mustache.js @@ -1,1 +1,311 @@ +/* +Shameless port of a shameless port +@defunkt => @janl => @aq + +See http://github.com/defunkt/mustache for more info. +*/ + +;(function($) { +/* +Shamless port of http://github.com/defunkt/mustache +by Jan Lehnardt <jan@apache.org>, +Alexander Lang <alex@upstream-berlin.com>, +Sebastian Cohnen <sebastian.cohnen@googlemail.com> + +Thanks @defunkt for the awesome code. + +See http://github.com/defunkt/mustache for more info. +*/ + +var Mustache = function() { + var Renderer = function() {}; + + Renderer.prototype = { + otag: "{{", + ctag: "}}", + pragmas: {}, + buffer: [], + pragmas_parsed: false, + + render: function(template, context, partials, in_recursion) { + // fail fast + if(template.indexOf(this.otag) == -1) { + if(in_recursion) { + return template; + } else { + this.send(template); + return; + } + } + + if(!in_recursion) { + this.buffer = []; + } + + if(!this.pragmas_parsed) { + template = this.render_pragmas(template); + } + var html = this.render_section(template, context, partials); + if(in_recursion) { + return this.render_tags(html, context, partials, in_recursion); + } + + this.render_tags(html, context, partials, in_recursion); + }, + + /* +Sends parsed lines +*/ + send: function(line) { + if(line != "") { + this.buffer.push(line); + } + }, + + /* +Looks for %PRAGMAS +*/ + render_pragmas: function(template) { + this.pragmas_parsed = true; + // no pragmas + if(template.indexOf(this.otag + "%") == -1) { + return template; + } + + var that = this; + var regex = new RegExp(this.otag + "%([\\w_-]+) ?([\\w]+=[\\w]+)?" + + this.ctag); + return template.replace(regex, function(match, pragma, options) { + that.pragmas[pragma] = {}; + if(options) { + var opts = options.split("="); + that.pragmas[pragma][opts[0]] = opts[1]; + } + return ""; + // ignore unknown pragmas silently + }); + }, + + /* +Tries to find a partial in the global scope and render it +*/ + render_partial: function(name, context, partials) { + if(typeof(context[name]) != "object") { + throw({message: "subcontext for '" + name + "' is not an object"}); + } + if(!partials || !partials[name]) { + throw({message: "unknown_partial '" + name + "'"}); + } + return this.render(partials[name], context[name], partials, true); + }, + + /* +Renders boolean and enumerable sections +*/ + render_section: function(template, context, partials) { + if(template.indexOf(this.otag + "#") == -1) { + return template; + } + var that = this; + // CSW - Added "+?" so it finds the tighest bound, not the widest + var regex = new RegExp(this.otag + "\\#(.+)" + this.ctag + + "\\s*([\\s\\S]+?)" + this.otag + "\\/\\1" + this.ctag + "\\s*", "mg"); + + // for each {{#foo}}{{/foo}} section do... + return template.replace(regex, function(match, name, content) { + var value = that.find(name, context); + if(that.is_array(value)) { // Enumerable, Let's loop! + return that.map(value, function(row) { + return that.render(content, that.merge(context, + that.create_context(row)), partials, true); + }).join(""); + } else if(value) { // boolean section + return that.render(content, context, partials, true); + } else { + return ""; + } + }); + }, + + /* +Replace {{foo}} and friends with values from our view +*/ + render_tags: function(template, context, partials, in_recursion) { + // tit for tat + var that = this; + + var new_regex = function() { + return new RegExp(that.otag + "(=|!|>|\\{|%)?([^\/#]+?)\\1?" + + that.ctag + "+", "g"); + }; + + var regex = new_regex(); + var lines = template.split("\n"); + for (var i=0; i < lines.length; i++) { + lines[i] = lines[i].replace(regex, function(match, operator, name) { + switch(operator) { + case "!": // ignore comments + return match; + case "=": // set new delimiters, rebuild the replace regexp + that.set_delimiters(name); + regex = new_regex(); + return ""; + case ">": // render partial + return that.render_partial(name, context, partials); + case "{": // the triple mustache is unescaped + return that.find(name, context); + default: // escape the value + return that.escape(that.find(name, context)); + } + }, this); + if(!in_recursion) { + this.send(lines[i]); + } + } + + if(in_recursion) { + return lines.join("\n"); + } + }, + + set_delimiters: function(delimiters) { + var dels = delimiters.split(" "); + this.otag = this.escape_regex(dels[0]); + this.ctag = this.escape_regex(dels[1]); + }, + + escape_regex: function(text) { + // thank you Simon Willison + if(!arguments.callee.sRE) { + var specials = [ + '/', '.', '*', '+', '?', '|', + '(', ')', '[', ']', '{', '}', '\\' + ]; + arguments.callee.sRE = new RegExp( + '(\\' + specials.join('|\\') + ')', 'g' + ); + } + return text.replace(arguments.callee.sRE, '\\$1'); + }, + + /* +find `name` in current `context`. That is find me a value +from the view object +*/ + find: function(name, context) { + name = this.trim(name); + if(typeof context[name] === "function") { + return context[name].apply(context); + } + if(context[name] !== undefined) { + return context[name]; + } + // silently ignore unkown variables + return ""; + }, + + // Utility methods + + /* +Does away with nasty characters +*/ + escape: function(s) { + return ((s == null) ? "" : s).toString().replace(/[&"<>\\]/g, function(s) { + switch(s) { + case "&": return "&"; + case "\\": return "\\\\";; + case '"': return '\"';; + case "<": return "<"; + case ">": return ">"; + default: return s; + } + }); + }, + + /* +Merges all properties of object `b` into object `a`. +`b.property` overwrites a.property` +*/ + merge: function(a, b) { + var _new = {}; + for(var name in a) { + if(a.hasOwnProperty(name)) { + _new[name] = a[name]; + } + }; + for(var name in b) { + if(b.hasOwnProperty(name)) { + _new[name] = b[name]; + } + }; + return _new; + }, + + // by @langalex, support for arrays of strings + create_context: function(_context) { + if(this.is_object(_context)) { + return _context; + } else if(this.pragmas["IMPLICIT-ITERATOR"]) { + var iterator = this.pragmas["IMPLICIT-ITERATOR"].iterator || "."; + var ctx = {}; + ctx[iterator] = _context + return ctx; + } + }, + + is_object: function(a) { + return a && typeof a == "object"; + }, + + is_array: function(a) { + return Object.prototype.toString.call(a) === '[object Array]'; + }, + + /* +Gets rid of leading and trailing whitespace +*/ + trim: function(s) { + return s.replace(/^\s*|\s*$/g, ""); + }, + + /* +Why, why, why? Because IE. Cry, cry cry. +*/ + map: function(array, fn) { + if (typeof array.map == "function") { + return array.map(fn) + } else { + var r = []; + var l = array.length; + for(i=0;i<l;i++) { + r.push(fn(array[i])); + } + return r; + } + } + }; + + return({ + name: "mustache.js", + version: "0.2.3-dev", + + /* +Turns a template and view into HTML +*/ + to_html: function(template, view, partials, send_fun) { + var renderer = new Renderer(); + if(send_fun) { + renderer.send = send_fun; + } + renderer.render(template, view, partials); + if(!send_fun) { + return renderer.buffer.join("\n"); + } + } + }); +}(); + $.mustache = Mustache.to_html; + +})(jQuery); +