third-party/mustache/mustache.js

   1 /*!
   2  * mustache.js - Logic-less {{mustache}} templates with JavaScript
   3  * http://github.com/janl/mustache.js
   4  */
   5
   6 /*global define: false*/
   7
   8 (function (root, factory) {
   9   if (typeof exports === "object" && exports) {
  10     factory(exports); // CommonJS
  11   } else {
  12     var mustache = {};
  13     factory(mustache);
  14     if (typeof define === "function" && define.amd) {
  15       define(mustache); // AMD
  16     } else {
  17       root.Mustache = mustache; // <script>
  18     }
  19   }
  20 }(this, function (mustache) {
  21
  22   var whiteRe = /\s*/;
  23   var spaceRe = /\s+/;
  24   var nonSpaceRe = /\S/;
  25   var eqRe = /\s*=/;
  26   var curlyRe = /\s*\}/;
  27   var tagRe = /#|\^|\/|>|\{|&|=|!/;
  28
  29   // Workaround for https://issues.apache.org/jira/browse/COUCHDB-577
  30   // See https://github.com/janl/mustache.js/issues/189
  31   var RegExp_test = RegExp.prototype.test;
  32   function testRegExp(re, string) {
  33     return RegExp_test.call(re, string);
  34   }
  35
  36   function isWhitespace(string) {
  37     return !testRegExp(nonSpaceRe, string);
  38   }
  39
  40   var Object_toString = Object.prototype.toString;
  41   var isArray = Array.isArray || function (obj) {
  42     return Object_toString.call(obj) === '[object Array]';
  43   };
  44
  45   function escapeRegExp(string) {
  46     return string.replace(/[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&");
  47   }
  48
  49   var entityMap = {
  50     "&": "&amp;",
  51     "<": "&lt;",
  52     ">": "&gt;",
  53     '"': '&quot;',
  54     "'": '&#39;',
  55     "/": '&#x2F;'
  56   };
  57
  58   function escapeHtml(string) {
  59     return String(string).replace(/[&<>"'\/]/g, function (s) {
  60       return entityMap[s];
  61     });
  62   }
  63
  64   function Scanner(string) {
  65     this.string = string;
  66     this.tail = string;
  67     this.pos = 0;
  68   }
  69
  70   /**
  71    * Returns `true` if the tail is empty (end of string).
  72    */
  73   Scanner.prototype.eos = function () {
  74     return this.tail === "";
  75   };
  76
  77   /**
  78    * Tries to match the given regular expression at the current position.
  79    * Returns the matched text if it can match, the empty string otherwise.
  80    */
  81   Scanner.prototype.scan = function (re) {
  82     var match = this.tail.match(re);
  83
  84     if (match && match.index === 0) {
  85       this.tail = this.tail.substring(match[0].length);
  86       this.pos += match[0].length;
  87       return match[0];
  88     }
  89
  90     return "";
  91   };
  92
  93   /**
  94    * Skips all text until the given regular expression can be matched. Returns
  95    * the skipped string, which is the entire tail if no match can be made.
  96    */
  97   Scanner.prototype.scanUntil = function (re) {
  98     var match, pos = this.tail.search(re);
  99
 100     switch (pos) {
 101     case -1:
 102       match = this.tail;
 103       this.pos += this.tail.length;
 104       this.tail = "";
 105       break;
 106     case 0:
 107       match = "";
 108       break;
 109     default:
 110       match = this.tail.substring(0, pos);
 111       this.tail = this.tail.substring(pos);
 112       this.pos += pos;
 113     }
 114
 115     return match;
 116   };
 117
 118   function Context(view, parent) {
 119     this.view = view || {};
 120     this.parent = parent;
 121     this._cache = {};
 122   }
 123
 124   Context.make = function (view) {
 125     return (view instanceof Context) ? view : new Context(view);
 126   };
 127
 128   Context.prototype.push = function (view) {
 129     return new Context(view, this);
 130   };
 131
 132   Context.prototype.lookup = function (name) {
 133     var value = this._cache[name];
 134
 135     if (!value) {
 136       if (name == '.') {
 137         value = this.view;
 138       } else {
 139         var context = this;
 140
 141         while (context) {
 142           if (name.indexOf('.') > 0) {
 143             value = context.view;
 144             var names = name.split('.'), i = 0;
 145             while (value && i < names.length) {
 146               value = value[names[i++]];
 147             }
 148           } else {
 149             value = context.view[name];
 150           }
 151
 152           if (value != null) break;
 153
 154           context = context.parent;
 155         }
 156       }
 157
 158       this._cache[name] = value;
 159     }
 160
 161     if (typeof value === 'function') value = value.call(this.view);
 162
 163     return value;
 164   };
 165
 166   function Writer() {
 167     this.clearCache();
 168   }
 169
 170   Writer.prototype.clearCache = function () {
 171     this._cache = {};
 172     this._partialCache = {};
 173   };
 174
 175   Writer.prototype.compile = function (template, tags) {
 176     var fn = this._cache[template];
 177
 178     if (!fn) {
 179       var tokens = mustache.parse(template, tags);
 180       fn = this._cache[template] = this.compileTokens(tokens, template);
 181     }
 182
 183     return fn;
 184   };
 185
 186   Writer.prototype.compilePartial = function (name, template, tags) {
 187     var fn = this.compile(template, tags);
 188     this._partialCache[name] = fn;
 189     return fn;
 190   };
 191
 192   Writer.prototype.getPartial = function (name) {
 193     if (!(name in this._partialCache) && this._loadPartial) {
 194       this.compilePartial(name, this._loadPartial(name));
 195     }
 196
 197     return this._partialCache[name];
 198   };
 199
 200   Writer.prototype.compileTokens = function (tokens, template) {
 201     var self = this;
 202     return function (view, partials) {
 203       if (partials) {
 204         if (typeof partials === 'function') {
 205           self._loadPartial = partials;
 206         } else {
 207           for (var name in partials) {
 208             self.compilePartial(name, partials[name]);
 209           }
 210         }
 211       }
 212
 213       return renderTokens(tokens, self, Context.make(view), template);
 214     };
 215   };
 216
 217   Writer.prototype.render = function (template, view, partials) {
 218     return this.compile(template)(view, partials);
 219   };
 220
 221   /**
 222    * Low-level function that renders the given `tokens` using the given `writer`
 223    * and `context`. The `template` string is only needed for templates that use
 224    * higher-order sections to extract the portion of the original template that
 225    * was contained in that section.
 226    */
 227   function renderTokens(tokens, writer, context, template) {
 228     var buffer = '';
 229
 230     var token, tokenValue, value;
 231     for (var i = 0, len = tokens.length; i < len; ++i) {
 232       token = tokens[i];
 233       tokenValue = token[1];
 234
 235       switch (token[0]) {
 236       case '#':
 237         value = context.lookup(tokenValue);
 238
 239         if (typeof value === 'object') {
 240           if (isArray(value)) {
 241             for (var j = 0, jlen = value.length; j < jlen; ++j) {
 242               buffer += renderTokens(token[4], writer, context.push(value[j]), template);
 243             }
 244           } else if (value) {
 245             buffer += renderTokens(token[4], writer, context.push(value), template);
 246           }
 247         } else if (typeof value === 'function') {
 248           var text = template == null ? null : template.slice(token[3], token[5]);
 249           value = value.call(context.view, text, function (template) {
 250             return writer.render(template, context);
 251           });
 252           if (value != null) buffer += value;
 253         } else if (value) {
 254           buffer += renderTokens(token[4], writer, context, template);
 255         }
 256
 257         break;
 258       case '^':
 259         value = context.lookup(tokenValue);
 260
 261         // Use JavaScript's definition of falsy. Include empty arrays.
 262         // See https://github.com/janl/mustache.js/issues/186
 263         if (!value || (isArray(value) && value.length === 0)) {
 264           buffer += renderTokens(token[4], writer, context, template);
 265         }
 266
 267         break;
 268       case '>':
 269         value = writer.getPartial(tokenValue);
 270         if (typeof value === 'function') buffer += value(context);
 271         break;
 272       case '&':
 273         value = context.lookup(tokenValue);
 274         if (value != null) buffer += value;
 275         break;
 276       case 'name':
 277         value = context.lookup(tokenValue);
 278         if (value != null) buffer += mustache.escape(value);
 279         break;
 280       case 'text':
 281         buffer += tokenValue;
 282         break;
 283       }
 284     }
 285
 286     return buffer;
 287   }
 288
 289   /**
 290    * Forms the given array of `tokens` into a nested tree structure where
 291    * tokens that represent a section have two additional items: 1) an array of
 292    * all tokens that appear in that section and 2) the index in the original
 293    * template that represents the end of that section.
 294    */
 295   function nestTokens(tokens) {
 296     var tree = [];
 297     var collector = tree;
 298     var sections = [];
 299
 300     var token;
 301     for (var i = 0, len = tokens.length; i < len; ++i) {
 302       token = tokens[i];
 303       switch (token[0]) {
 304       case '#':
 305       case '^':
 306         sections.push(token);
 307         collector.push(token);
 308         collector = token[4] = [];
 309         break;
 310       case '/':
 311         var section = sections.pop();
 312         section[5] = token[2];
 313         collector = sections.length > 0 ? sections[sections.length - 1][4] : tree;
 314         break;
 315       default:
 316         collector.push(token);
 317       }
 318     }
 319
 320     return tree;
 321   }
 322
 323   /**
 324    * Combines the values of consecutive text tokens in the given `tokens` array
 325    * to a single token.
 326    */
 327   function squashTokens(tokens) {
 328     var squashedTokens = [];
 329
 330     var token, lastToken;
 331     for (var i = 0, len = tokens.length; i < len; ++i) {
 332       token = tokens[i];
 333       if (token) {
 334         if (token[0] === 'text' && lastToken && lastToken[0] === 'text') {
 335           lastToken[1] += token[1];
 336           lastToken[3] = token[3];
 337         } else {
 338           lastToken = token;
 339           squashedTokens.push(token);
 340         }
 341       }
 342     }
 343
 344     return squashedTokens;
 345   }
 346
 347   function escapeTags(tags) {
 348     return [
 349       new RegExp(escapeRegExp(tags[0]) + "\\s*"),
 350       new RegExp("\\s*" + escapeRegExp(tags[1]))
 351     ];
 352   }
 353
 354   /**
 355    * Breaks up the given `template` string into a tree of token objects. If
 356    * `tags` is given here it must be an array with two string values: the
 357    * opening and closing tags used in the template (e.g. ["<%", "%>"]). Of
 358    * course, the default is to use mustaches (i.e. Mustache.tags).
 359    */
 360   function parseTemplate(template, tags) {
 361     template = template || '';
 362     tags = tags || mustache.tags;
 363
 364     if (typeof tags === 'string') tags = tags.split(spaceRe);
 365     if (tags.length !== 2) throw new Error('Invalid tags: ' + tags.join(', '));
 366
 367     var tagRes = escapeTags(tags);
 368     var scanner = new Scanner(template);
 369
 370     var sections = [];     // Stack to hold section tokens
 371     var tokens = [];       // Buffer to hold the tokens
 372     var spaces = [];       // Indices of whitespace tokens on the current line
 373     var hasTag = false;    // Is there a {{tag}} on the current line?
 374     var nonSpace = false;  // Is there a non-space char on the current line?
 375
 376     // Strips all whitespace tokens array for the current line
 377     // if there was a {{#tag}} on it and otherwise only space.
 378     function stripSpace() {
 379       if (hasTag && !nonSpace) {
 380         while (spaces.length) {
 381           delete tokens[spaces.pop()];
 382         }
 383       } else {
 384         spaces = [];
 385       }
 386
 387       hasTag = false;
 388       nonSpace = false;
 389     }
 390
 391     var start, type, value, chr, token;
 392     while (!scanner.eos()) {
 393       start = scanner.pos;
 394
 395       // Match any text between tags.
 396       value = scanner.scanUntil(tagRes[0]);
 397       if (value) {
 398         for (var i = 0, len = value.length; i < len; ++i) {
 399           chr = value.charAt(i);
 400
 401           if (isWhitespace(chr)) {
 402             spaces.push(tokens.length);
 403           } else {
 404             nonSpace = true;
 405           }
 406
 407           tokens.push(['text', chr, start, start + 1]);
 408           start += 1;
 409
 410           // Check for whitespace on the current line.
 411           if (chr == '\n') stripSpace();
 412         }
 413       }
 414
 415       // Match the opening tag.
 416       if (!scanner.scan(tagRes[0])) break;
 417       hasTag = true;
 418
 419       // Get the tag type.
 420       type = scanner.scan(tagRe) || 'name';
 421       scanner.scan(whiteRe);
 422
 423       // Get the tag value.
 424       if (type === '=') {
 425         value = scanner.scanUntil(eqRe);
 426         scanner.scan(eqRe);
 427         scanner.scanUntil(tagRes[1]);
 428       } else if (type === '{') {
 429         value = scanner.scanUntil(new RegExp('\\s*' + escapeRegExp('}' + tags[1])));
 430         scanner.scan(curlyRe);
 431         scanner.scanUntil(tagRes[1]);
 432         type = '&';
 433       } else {
 434         value = scanner.scanUntil(tagRes[1]);
 435       }
 436
 437       // Match the closing tag.
 438       if (!scanner.scan(tagRes[1])) throw new Error('Unclosed tag at ' + scanner.pos);
 439
 440       token = [type, value, start, scanner.pos];
 441       tokens.push(token);
 442
 443       if (type === '#' || type === '^') {
 444         sections.push(token);
 445       } else if (type === '/') {
 446         // Check section nesting.
 447         if (sections.length === 0) throw new Error('Unopened section "' + value + '" at ' + start);
 448         var openSection = sections.pop();
 449         if (openSection[1] !== value) throw new Error('Unclosed section "' + openSection[1] + '" at ' + start);
 450       } else if (type === 'name' || type === '{' || type === '&') {
 451         nonSpace = true;
 452       } else if (type === '=') {
 453         // Set the tags for the next time around.
 454         tags = value.split(spaceRe);
 455         if (tags.length !== 2) throw new Error('Invalid tags at ' + start + ': ' + tags.join(', '));
 456         tagRes = escapeTags(tags);
 457       }
 458     }
 459
 460     // Make sure there are no open sections when we're done.
 461     var openSection = sections.pop();
 462     if (openSection) throw new Error('Unclosed section "' + openSection[1] + '" at ' + scanner.pos);
 463
 464     tokens = squashTokens(tokens);
 465
 466     return nestTokens(tokens);
 467   }
 468
 469   mustache.name = "mustache.js";
 470   mustache.version = "0.7.2";
 471   mustache.tags = ["{{", "}}"];
 472
 473   mustache.Scanner = Scanner;
 474   mustache.Context = Context;
 475   mustache.Writer = Writer;
 476
 477   mustache.parse = parseTemplate;
 478
 479   // Export the escaping function so that the user may override it.
 480   // See https://github.com/janl/mustache.js/issues/244
 481   mustache.escape = escapeHtml;
 482
 483   // All Mustache.* functions use this writer.
 484   var defaultWriter = new Writer();
 485
 486   /**
 487    * Clears all cached templates and partials in the default writer.
 488    */
 489   mustache.clearCache = function () {
 490     return defaultWriter.clearCache();
 491   };
 492
 493   /**
 494    * Compiles the given `template` to a reusable function using the default
 495    * writer.
 496    */
 497   mustache.compile = function (template, tags) {
 498     return defaultWriter.compile(template, tags);
 499   };
 500
 501   /**
 502    * Compiles the partial with the given `name` and `template` to a reusable
 503    * function using the default writer.
 504    */
 505   mustache.compilePartial = function (name, template, tags) {
 506     return defaultWriter.compilePartial(name, template, tags);
 507   };
 508
 509   /**
 510    * Compiles the given array of tokens (the output of a parse) to a reusable
 511    * function using the default writer.
 512    */
 513   mustache.compileTokens = function (tokens, template) {
 514     return defaultWriter.compileTokens(tokens, template);
 515   };
 516
 517   /**
 518    * Renders the `template` with the given `view` and `partials` using the
 519    * default writer.
 520    */
 521   mustache.render = function (template, view, partials) {
 522     return defaultWriter.render(template, view, partials);
 523   };
 524
 525   // This is here for backwards compatibility with 0.4.x.
 526   mustache.to_html = function (template, view, partials, send) {
 527     var result = mustache.render(template, view, partials);
 528
 529     if (typeof send === "function") {
 530       send(result);
 531     } else {
 532       return result;
 533     }
 534   };
 535
 536 }));