Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Browse files

Update mustache.js in the demo to the current version (0.4)

  • Loading branch information...
commit b31c599c92a2749bb35dbfe76495da17f0152fb6 1 parent 8a325a7
Ben Cherry authored
Showing with 290 additions and 152 deletions.
  1. +290 −152 extras/mustache.js
442 extras/mustache.js
View
@@ -1,28 +1,77 @@
/*
- Shameless 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>
+ mustache.js — Logic-less templates in JavaScript
- Thanks @defunkt for the awesome code.
-
- See http://github.com/defunkt/mustache for more info.
+ See http://mustache.github.com/ for more info.
*/
-var Mustache = function() {
- var Renderer = function() {};
+var Mustache = function () {
+ var _toString = Object.prototype.toString;
+
+ Array.isArray = Array.isArray || function (obj) {
+ return _toString.call(obj) == "[object Array]";
+ }
+
+ var _trim = String.prototype.trim, trim;
+
+ if (_trim) {
+ trim = function (text) {
+ return text == null ? "" : _trim.call(text);
+ }
+ } else {
+ var trimLeft, trimRight;
+
+ // IE doesn't match non-breaking spaces with \s.
+ if ((/\S/).test("\xA0")) {
+ trimLeft = /^[\s\xA0]+/;
+ trimRight = /[\s\xA0]+$/;
+ } else {
+ trimLeft = /^\s+/;
+ trimRight = /\s+$/;
+ }
+
+ trim = function (text) {
+ return text == null ? "" :
+ text.toString().replace(trimLeft, "").replace(trimRight, "");
+ }
+ }
+
+ var escapeMap = {
+ "&": "&amp;",
+ "<": "&lt;",
+ ">": "&gt;",
+ '"': '&quot;',
+ "'": '&#39;'
+ };
+
+ function escapeHTML(string) {
+ return String(string).replace(/&(?!\w+;)|[<>"']/g, function (s) {
+ return escapeMap[s] || s;
+ });
+ }
+
+ var regexCache = {};
+ var Renderer = function () {};
Renderer.prototype = {
otag: "{{",
ctag: "}}",
pragmas: {},
buffer: [],
- pragmas_parsed: false,
+ pragmas_implemented: {
+ "IMPLICIT-ITERATOR": true
+ },
+ context: {},
+
+ render: function (template, context, partials, in_recursion) {
+ // reset buffer & set context
+ if (!in_recursion) {
+ this.context = context;
+ this.buffer = []; // TODO: make this non-lazy
+ }
- render: function(template, context, partials, in_recursion) {
// fail fast
- if(template.indexOf(this.otag) == -1) {
- if(in_recursion) {
+ if (!this.includes("", template)) {
+ if (in_recursion) {
return template;
} else {
this.send(template);
@@ -30,46 +79,64 @@ var Mustache = function() {
}
}
- if(!in_recursion) {
- this.buffer = [];
- }
+ // get the pragmas together
+ template = this.render_pragmas(template);
- if(!this.pragmas_parsed) {
- template = this.render_pragmas(template);
- }
+ // render the template
var html = this.render_section(template, context, partials);
- if(in_recursion) {
- return this.render_tags(html, context, partials, in_recursion);
+
+ // render_section did not find any sections, we still need to render the tags
+ if (html === false) {
+ html = this.render_tags(template, context, partials, in_recursion);
}
- this.render_tags(html, context, partials, in_recursion);
+ if (in_recursion) {
+ return html;
+ } else {
+ this.sendLines(html);
+ }
},
/*
Sends parsed lines
*/
- send: function(line) {
- if(line != "") {
+ send: function (line) {
+ if (line !== "") {
this.buffer.push(line);
}
},
+ sendLines: function (text) {
+ if (text) {
+ var lines = text.split("\n");
+ for (var i = 0; i < lines.length; i++) {
+ this.send(lines[i]);
+ }
+ }
+ },
+
/*
Looks for %PRAGMAS
*/
- render_pragmas: function(template) {
- this.pragmas_parsed = true;
+ render_pragmas: function (template) {
// no pragmas
- if(template.indexOf(this.otag + "%") == -1) {
+ if (!this.includes("%", template)) {
return template;
}
var that = this;
- var regex = new RegExp(this.otag + "%([\\w_-]+) ?([\\w]+=[\\w]+)?"
- + this.ctag);
- return template.replace(regex, function(match, pragma, options) {
+ var regex = this.getCachedRegex("render_pragmas", function (otag, ctag) {
+ return new RegExp(otag + "%([\\w-]+) ?([\\w]+=[\\w]+)?" + ctag, "g");
+ });
+
+ return template.replace(regex, function (match, pragma, options) {
+ if (!that.pragmas_implemented[pragma]) {
+ throw({message:
+ "This implementation of mustache doesn't understand the '" +
+ pragma + "' pragma"});
+ }
that.pragmas[pragma] = {};
- if(options) {
+ if (options) {
var opts = options.split("=");
that.pragmas[pragma][opts[0]] = opts[1];
}
@@ -79,96 +146,148 @@ var Mustache = function() {
},
/*
- Tries to find a partial in the global scope and render it
+ Tries to find a partial in the curent 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]) {
+ render_partial: function (name, context, partials) {
+ name = trim(name);
+ if (!partials || partials[name] === undefined) {
throw({message: "unknown_partial '" + name + "'"});
}
+ if (!context || typeof context[name] != "object") {
+ return this.render(partials[name], context, partials, true);
+ }
return this.render(partials[name], context[name], partials, true);
},
/*
- Renders boolean and enumerable sections
+ Renders inverted (^) and normal (#) sections
*/
- render_section: function(template, context, partials) {
- if(template.indexOf(this.otag + "#") == -1) {
- return template;
+ render_section: function (template, context, partials) {
+ if (!this.includes("#", template) && !this.includes("^", template)) {
+ // did not render anything, there were no sections
+ return false;
}
+
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");
+
+ var regex = this.getCachedRegex("render_section", function (otag, ctag) {
+ // This regex matches _the first_ section ({{#foo}}{{/foo}}), and captures the remainder
+ return new RegExp(
+ "^([\\s\\S]*?)" + // all the crap at the beginning that is not {{*}} ($1)
+
+ otag + // {{
+ "(\\^|\\#)\\s*(.+)\\s*" + // #foo (# == $2, foo == $3)
+ ctag + // }}
+
+ "\n*([\\s\\S]*?)" + // between the tag ($2). leading newlines are dropped
+
+ otag + // {{
+ "\\/\\s*\\3\\s*" + // /foo (backreference to the opening tag).
+ ctag + // }}
+
+ "\\s*([\\s\\S]*)$", // everything else in the string ($4). leading whitespace is dropped.
+
+ "g");
+ });
+
// 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 "";
+ return template.replace(regex, function (match, before, type, name, content, after) {
+ // before contains only tags, no sections
+ var renderedBefore = before ? that.render_tags(before, context, partials, true) : "",
+
+ // after may contain both sections and tags, so use full rendering function
+ renderedAfter = after ? that.render(after, context, partials, true) : "",
+
+ // will be computed below
+ renderedContent,
+
+ value = that.find(name, context);
+
+ if (type === "^") { // inverted section
+ if (!value || Array.isArray(value) && value.length === 0) {
+ // false or empty list, render it
+ renderedContent = that.render(content, context, partials, true);
+ } else {
+ renderedContent = "";
+ }
+ } else if (type === "#") { // normal section
+ if (Array.isArray(value)) { // Enumerable, Let's loop!
+ renderedContent = that.map(value, function (row) {
+ return that.render(content, that.create_context(row), partials, true);
+ }).join("");
+ } else if (that.is_object(value)) { // Object, Use it as subcontext!
+ renderedContent = that.render(content, that.create_context(value),
+ partials, true);
+ } else if (typeof value == "function") {
+ // higher order section
+ renderedContent = value.call(context, content, function (text) {
+ return that.render(text, context, partials, true);
+ });
+ } else if (value) { // boolean section
+ renderedContent = that.render(content, context, partials, true);
+ } else {
+ renderedContent = "";
+ }
}
+
+ return renderedBefore + renderedContent + renderedAfter;
});
},
/*
Replace {{foo}} and friends with values from our view
*/
- render_tags: function(template, context, partials, in_recursion) {
+ 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 new_regex = function () {
+ return that.getCachedRegex("render_tags", function (otag, ctag) {
+ return new RegExp(otag + "(=|!|>|&|\\{|%)?([^#\\^]+?)\\1?" + ctag + "+", "g");
+ });
};
var regex = new_regex();
+ var tag_replace_callback = function (match, operator, name) {
+ switch(operator) {
+ case "!": // ignore comments
+ return "";
+ 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
+ case "&": // & operator is an alternative unescape method
+ return that.find(name, context);
+ default: // escape the value
+ return escapeHTML(that.find(name, context));
+ }
+ };
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");
- }
+ for(var i = 0; i < lines.length; i++) {
+ lines[i] = lines[i].replace(regex, tag_replace_callback, this);
+ if (!in_recursion) {
+ this.send(lines[i]);
+ }
+ }
+
+ if (in_recursion) {
+ return lines.join("\n");
+ }
},
- set_delimiters: function(delimiters) {
+ 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) {
+ escape_regex: function (text) {
// thank you Simon Willison
- if(!arguments.callee.sRE) {
+ if (!arguments.callee.sRE) {
var specials = [
'/', '.', '*', '+', '?', '|',
'(', ')', '[', ']', '{', '}', '\\'
@@ -177,120 +296,139 @@ var Mustache = function() {
'(\\' + specials.join('|\\') + ')', 'g'
);
}
- return text.replace(arguments.callee.sRE, '\\$1');
+ 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);
+ find: function (name, context) {
+ name = trim(name);
+
+ // Checks whether a value is thruthy or false or 0
+ function is_kinda_truthy(bool) {
+ return bool === false || bool === 0 || bool;
+ }
+
+ var value;
+
+ // check for dot notation eg. foo.bar
+ if (name.match(/([a-z_]+)\./ig)) {
+ var childValue = this.walk_context(name, context);
+ if (is_kinda_truthy(childValue)) {
+ value = childValue;
+ }
+ } else {
+ if (is_kinda_truthy(context[name])) {
+ value = context[name];
+ } else if (is_kinda_truthy(this.context[name])) {
+ value = this.context[name];
+ }
+ }
+
+ if (typeof value == "function") {
+ return value.apply(context);
}
- if(context[name] !== undefined) {
- return context[name];
+ if (value !== undefined) {
+ return value;
}
// 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 "&amp;";
- case "\\": return "\\\\";;
- case '"': return '\"';;
- case "<": return "&lt;";
- case ">": return "&gt;";
- default: return s;
- }
- });
+ walk_context: function (name, context) {
+ var path = name.split('.');
+ // if the var doesn't exist in current context, check the top level context
+ var value_context = (context[path[0]] != undefined) ? context : this.context;
+ var value = value_context[path.shift()];
+ while (value != undefined && path.length > 0) {
+ value_context = value;
+ value = value[path.shift()];
+ }
+ // if the value is a function, call it, binding the correct context
+ if (typeof value == "function") {
+ return value.apply(value_context);
+ }
+ return value;
},
- /*
- 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;
+ // Utility methods
+
+ /* includes tag */
+ includes: function (needle, haystack) {
+ return haystack.indexOf(this.otag + needle) != -1;
},
// by @langalex, support for arrays of strings
- create_context: function(_context) {
- if(this.is_object(_context)) {
+ create_context: function (_context) {
+ if (this.is_object(_context)) {
return _context;
- } else if(this.pragmas["IMPLICIT-ITERATOR"]) {
- var iterator = this.pragmas["IMPLICIT-ITERATOR"].iterator || ".";
+ } else {
+ var iterator = ".";
+ if (this.pragmas["IMPLICIT-ITERATOR"]) {
+ iterator = this.pragmas["IMPLICIT-ITERATOR"].iterator;
+ }
var ctx = {};
- ctx[iterator] = _context
+ ctx[iterator] = _context;
return ctx;
}
},
- is_object: function(a) {
+ 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) {
+ map: function (array, fn) {
if (typeof array.map == "function") {
- return array.map(fn)
+ return array.map(fn);
} else {
var r = [];
var l = array.length;
- for(i=0;i<l;i++) {
+ for(var i = 0; i < l; i++) {
r.push(fn(array[i]));
}
return r;
}
+ },
+
+ getCachedRegex: function (name, generator) {
+ var byOtag = regexCache[this.otag];
+ if (!byOtag) {
+ byOtag = regexCache[this.otag] = {};
+ }
+
+ var byCtag = byOtag[this.ctag];
+ if (!byCtag) {
+ byCtag = byOtag[this.ctag] = {};
+ }
+
+ var regex = byCtag[name];
+ if (!regex) {
+ regex = byCtag[name] = generator(this.otag, this.ctag);
+ }
+
+ return regex;
}
};
return({
name: "mustache.js",
- version: "0.2.3-dev",
+ version: "0.4.0",
/*
Turns a template and view into HTML
*/
- to_html: function(template, view, partials, send_fun) {
+ to_html: function (template, view, partials, send_fun) {
var renderer = new Renderer();
- if(send_fun) {
+ if (send_fun) {
renderer.send = send_fun;
}
- renderer.render(template, view, partials);
- if(!send_fun) {
+ renderer.render(template, view || {}, partials);
+ if (!send_fun) {
return renderer.buffer.join("\n");
}
}
Please sign in to comment.
Something went wrong with that request. Please try again.