hbs_plus 0.1.3

data/js/bench/benchwarmer.js

@@ -0,0 +1,147 @@
+
+var Benchmark = require("benchmark");
+
+var BenchWarmer = function(names) {
+  this.benchmarks = [];
+  this.currentBenches = [];
+  this.names = [];
+  this.errors = {};
+};
+
+var print = require("sys").print;
+
+BenchWarmer.prototype = {
+  winners: function(benches) {
+    var result = Benchmark.filter(benches, function(bench) { return bench.cycles; });
+
+    if (result.length > 1) {
+      result.sort(function(a, b) { return b.compare(a); });
+      first = result[0];
+      last  = result[result.length - 1];
+
+      var winners = [];
+
+      Benchmark.each(result, function(bench) {
+        if (bench.compare(first) === 0) {
+          winners.push(bench);
+        }
+      });
+
+      return winners;
+    } else {
+      return result;
+    }
+  },
+  suite: function(suite, fn) {
+    this.suiteName = suite;
+    this.first = true;
+
+    var self = this;
+
+    fn(function(name, benchFn) {
+      self.push(name, benchFn);
+    });
+  },
+  push: function(name, fn) {
+    if(this.names.indexOf(name) == -1) {
+      this.names.push(name);
+    }
+
+    var first = this.first, suiteName = this.suiteName, self = this;
+    this.first = false;
+
+    var bench = new Benchmark(function() {
+      fn();
+    }, {
+      name: this.suiteName + ": " + name,
+      onComplete: function() {
+        if(first) { self.startLine(suiteName); }
+        self.writeBench(bench);
+        self.currentBenches.push(bench);
+      }, onError: function() {
+        self.errors[this.name] = this;
+      }
+    });
+
+    this.benchmarks.push(bench);
+  },
+  bench: function() {
+    var benchSize = 0, names = this.names, self = this, i, l;
+
+    for(i=0, l=names.length; i<l; i++) {
+      var name = names[i];
+
+      if(benchSize < name.length) { benchSize = name.length; }
+    }
+
+    this.nameSize = benchSize + 2;
+    this.benchSize = 20;
+    var horSize = 0;
+
+    this.startLine("ops/msec");
+    horSize = horSize + "ops/msec    ".length;
+    for(i=0, l=names.length; i<l; i++) {
+      print(names[i] + new Array(this.benchSize - names[i].length + 1).join(" "));
+      horSize = horSize + this.benchSize;
+    }
+
+    print("WINNER(S)");
+    horSize = horSize + "WINNER(S)".length;
+
+    print("\n" + new Array(horSize + 1).join("-"));
+
+    Benchmark.invoke(this.benchmarks, {
+      name: "run",
+      onComplete: function() {
+        var errors = false, prop, bench;
+        for(prop in self.errors) { if(self.errors.hasOwnProperty(prop)) { errors = true; break; } }
+
+        if(errors) {
+          print("\n\nErrors:\n");
+          for(prop in self.errors) {
+            if(self.errors.hasOwnProperty(prop)) {
+              bench = self.errors[prop];
+              print("\n" + bench.name + ":\n");
+              print(bench.error.message);
+              if(bench.error.stack) {
+                print(bench.error.stack.join("\n"));
+              }
+              print("\n");
+            }
+          }
+        }
+      }
+    });
+  },
+  startLine: function(name) {
+    var winners = Benchmark.map(this.winners(this.currentBenches), function(bench) {
+      return bench.name.split(": ")[1];
+    });
+
+    this.currentBenches = [];
+
+    print(winners.join(", "));
+    print("\n");
+    var padding = this.nameSize - name.length + 1;
+    name = name + new Array(padding).join(" ");
+    print(name);
+  },
+  writeBench: function(bench) {
+    var out;
+
+    if(!bench.error) {
+      var count = bench.hz,
+          moe   = count * bench.stats.RME / 100;
+
+      out = Math.round(count / 1000) + " ±" + Math.round(moe / 1000) + " (" + bench.cycles + ")";
+    } else {
+      out = "E";
+    }
+
+    var padding = this.benchSize - out.length + 1;
+    out = out + new Array(padding).join(" ");
+    print(out);
+  }
+};
+
+module.exports = BenchWarmer;

data/js/bench/handlebars.js

@@ -0,0 +1,166 @@
+require.paths.push("lib");
+require.paths.push("vendor");
+require.paths.push("vendor/dustjs/lib");
+require.paths.push("vendor/coffee/lib");
+require.paths.push("vendor/eco/lib");
+
+
+var BenchWarmer = require("./benchwarmer");
+Handlebars = require("handlebars");
+
+var dust = require("dust");
+var Mustache = require("mustache");
+var ecoExports = require("eco");
+
+eco = function(str) {
+  var module = {};
+  var template = new Function("module", ecoExports.compile(str));
+  template(module);
+  return module.exports;
+}
+
+var benchDetails = {
+  string: {
+    context: {},
+    handlebars: "Hello world",
+    dust: "Hello world",
+    mustache: "Hello world",
+    eco: "Hello world"
+  },
+  variables: {
+    context: {name: "Mick", count: 30},
+    handlebars:  "Hello {{name}}! You have {{count}} new messages.",
+    dust: "Hello {name}! You have {count} new messages.",
+    mustache: "Hello {{name}}! You have {{count}} new messages.",
+    eco: "Hello <%= @name %>! You have <%= @count %> new messages."
+  },
+  object: {
+    context:  { person: { name: "Larry", age: 45 } },
+    handlebars: "{{#with person}}{{name}}{{age}}{{/with}}",
+    dust: "{#person}{name}{age}{/person}",
+    mustache: "{{#person}}{{name}}{{age}}{{/person}}"
+  },
+  array: {
+    context:  { names: [{name: "Moe"}, {name: "Larry"}, {name: "Curly"}, {name: "Shemp"}] },
+    handlebars: "{{#each names}}{{name}}{{/each}}",
+    dust: "{#names}{name}{/names}",
+    mustache: "{{#names}}{{name}}{{/names}}",
+    eco: "<% for item in @names: %><%= item.name %><% end %>"
+  },
+  partial: {
+    context: { peeps: [{name: "Moe", count: 15}, {name: "Larry", count: 5}, {name: "Curly", count: 1}] },
+    partials: {
+      mustache: { variables: "Hello {{name}}! You have {{count}} new messages." },
+      handlebars: { variables: "Hello {{name}}! You have {{count}} new messages." }
+    },
+    handlebars: "{{#each peeps}}{{>variables}}{{/each}}",
+    dust: "{#peeps}{>variables/}{/peeps}",
+    mustache: "{{#peeps}}{{>variables}}{{/peeps}}"
+  },
+  recursion: {
+    context: { name: '1', kids: [{ name: '1.1', kids: [{name: '1.1.1', kids: []}] }] },
+    partials: {
+      mustache: { recursion: "{{name}}{{#kids}}{{>recursion}}{{/kids}}" },
+      handlebars: { recursion: "{{name}}{{#each kids}}{{>recursion}}{{/each}}" }
+    },
+    handlebars: "{{name}}{{#each kids}}{{>recursion}}{{/each}}",
+    dust: "{name}{#kids}{>recursion:./}{/kids}",
+    mustache: "{{name}}{{#kids}}{{>recursion}}{{/kids}}"
+  },
+  complex: {
+    handlebars: "<h1>{{header}}</h1>{{#if items}}<ul>{{#each items}}{{#if current}}" +
+                "<li><strong>{{name}}</strong></li>{{^}}" +
+                "<li><a href=\"{{url}}\">{{name}}</a></li>{{/if}}" +
+                "{{/each}}</ul>{{^}}<p>The list is empty.</p>{{/if}}",
+
+    dust:       "<h1>{header}</h1>\n"                             +
+                "{?items}\n"                                      +
+                "  <ul>\n"                                        +
+                "    {#items}\n"                                  +
+                "      {#current}\n"                              +
+                "        <li><strong>{name}</strong></li>\n"      +
+                "      {:else}\n"                                 +
+                "        <li><a href=\"{url}\">{name}</a></li>\n" +
+                "      {/current}\n"                              +
+                "    {/items}\n"                                  +
+                "  </ul>\n"                                       +
+                "{:else}\n"                                       +
+                "  <p>The list is empty.</p>\n"                   +
+                "{/items}",
+    context: {
+               header: function() {
+                 return "Colors";
+               },
+               items: [
+                 {name: "red", current: true, url: "#Red"},
+                 {name: "green", current: false, url: "#Green"},
+                 {name: "blue", current: false, url: "#Blue"}
+               ]
+             }
+  }
+
+};
+
+handlebarsTemplates = {};
+ecoTemplates = {};
+
+var warmer = new BenchWarmer();
+
+var makeSuite = function(name) {
+  warmer.suite(name, function(bench) {
+    var templateName = name;
+    var details = benchDetails[templateName];
+    var mustachePartials = details.partials && details.partials.mustache;
+    var mustacheSource = details.mustache;
+    var context = details.context;
+
+    var error = function() { throw new Error("EWOT"); };
+
+
+    //bench("dust", function() {
+      //dust.render(templateName, context, function(err, out) { });
+    //});
+
+    bench("handlebars", function() {
+      handlebarsTemplates[templateName](context);
+    });
+
+    //if(ecoTemplates[templateName]) {
+      //bench("eco", function() {
+        //ecoTemplates[templateName](context);
+      //});
+    //} else {
+      //bench("eco", error);
+    //}
+
+    //if(mustacheSource) {
+      //bench("mustache", function() {
+        //Mustache.to_html(mustacheSource, context, mustachePartials);
+      //});
+    //} else {
+      //bench("mustache", error);
+    //}
+  });
+}
+
+for(var name in benchDetails) {
+  if(benchDetails.hasOwnProperty(name)) {
+    dust.loadSource(dust.compile(benchDetails[name].dust, name));
+    handlebarsTemplates[name] = Handlebars.compile(benchDetails[name].handlebars);
+
+    if(benchDetails[name].eco) { ecoTemplates[name] = eco(benchDetails[name].eco); }
+
+    var partials = benchDetails[name].partials;
+    if(partials) {
+      for(var partialName in partials.handlebars) {
+        if(partials.handlebars.hasOwnProperty(partialName)) {
+          Handlebars.registerPartial(partialName, partials.handlebars[partialName]);
+        }
+      }
+    }
+
+    makeSuite(name);
+  }
+}
+
+warmer.bench();

data/js/lib/handlebars.js

@@ -0,0 +1,15 @@
+var Handlebars = require("handlebars/base");
+module.exports = Handlebars;
+
+require("handlebars/utils");
+
+require("handlebars/ast");
+require("handlebars/printer");
+require("handlebars/visitor");
+
+require("handlebars/compiler");
+
+// BEGIN(BROWSER)
+
+// END(BROWSER)
+

data/js/lib/handlebars/ast.js

@@ -0,0 +1,103 @@
+var Handlebars = require("handlebars");
+
+// BEGIN(BROWSER)
+(function() {
+
+  Handlebars.AST = {};
+
+  Handlebars.AST.ProgramNode = function(statements, inverse) {
+    this.type = "program";
+    this.statements = statements;
+    if(inverse) { this.inverse = new Handlebars.AST.ProgramNode(inverse); }
+  };
+
+  Handlebars.AST.MustacheNode = function(params, hash, unescaped) {
+    this.type = "mustache";
+    this.id = params[0];
+    this.params = params.slice(1);
+    this.hash = hash;
+    this.escaped = !unescaped;
+  };
+
+  Handlebars.AST.PartialNode = function(id, context) {
+    this.type    = "partial";
+
+    // TODO: disallow complex IDs
+
+    this.id      = id;
+    this.context = context;
+  };
+
+  var verifyMatch = function(open, close) {
+    if(open.original !== close.original) {
+      throw new Handlebars.Exception(open.original + " doesn't match " + close.original);
+    }
+  };
+
+  Handlebars.AST.BlockNode = function(mustache, program, close) {
+    verifyMatch(mustache.id, close);
+    this.type = "block";
+    this.mustache = mustache;
+    this.program  = program;
+  };
+
+  Handlebars.AST.InverseNode = function(mustache, program, close) {
+    verifyMatch(mustache.id, close);
+    this.type = "inverse";
+    this.mustache = mustache;
+    this.program  = program;
+  };
+
+  Handlebars.AST.ContentNode = function(string) {
+    this.type = "content";
+    this.string = string;
+  };
+
+  Handlebars.AST.HashNode = function(pairs) {
+    this.type = "hash";
+    this.pairs = pairs;
+  };
+
+  Handlebars.AST.IdNode = function(parts) {
+    this.type = "ID";
+    this.original = parts.join(".");
+
+    var dig = [], depth = 0;
+
+    for(var i=0,l=parts.length; i<l; i++) {
+      var part = parts[i];
+
+      if(part === "..") { depth++; }
+      else if(part === "." || part === "this") { continue; }
+      else { dig.push(part); }
+    }
+
+    this.parts    = dig;
+    this.string   = dig.join('.');
+    this.depth    = depth;
+    this.isSimple = (dig.length === 1) && (depth === 0);
+  };
+
+  Handlebars.AST.StringNode = function(string) {
+    this.type = "STRING";
+    this.string = string;
+  };
+
+  Handlebars.AST.IntegerNode = function(integer) {
+    this.type = "INTEGER";
+    this.integer = integer;
+  };
+
+  Handlebars.AST.BooleanNode = function(bool) {
+    this.type = "BOOLEAN";
+    this.bool = bool;
+  };
+
+  Handlebars.AST.CommentNode = function(comment) {
+    this.type = "comment";
+    this.comment = comment;
+  };
+
+})();
+// END(BROWSER)
+

data/js/lib/handlebars/base.js

@@ -0,0 +1,114 @@
+var handlebars = require("handlebars/parser").parser;
+
+// BEGIN(BROWSER)
+var Handlebars = {};
+
+Handlebars.VERSION = "1.0.beta.2";
+
+Handlebars.Parser = handlebars;
+
+Handlebars.parse = function(string) {
+  Handlebars.Parser.yy = Handlebars.AST;
+  return Handlebars.Parser.parse(string);
+};
+
+Handlebars.print = function(ast) {
+  return new Handlebars.PrintVisitor().accept(ast);
+};
+
+Handlebars.helpers  = {};
+Handlebars.partials = {};
+
+Handlebars.registerHelper = function(name, fn, inverse) {
+  if(inverse) { fn.not = inverse; }
+  this.helpers[name] = fn;
+};
+
+Handlebars.registerPartial = function(name, str) {
+  this.partials[name] = str;
+};
+
+Handlebars.registerHelper('helperMissing', function(arg) {
+  if(arguments.length === 2) {
+    return undefined;
+  } else {
+    throw new Error("Could not find property '" + arg + "'");
+  }
+});
+
+Handlebars.registerHelper('blockHelperMissing', function(context, options) {
+  var inverse = options.inverse || function() {}, fn = options.fn;
+
+
+  var ret = "";
+  var type = Object.prototype.toString.call(context);
+
+  if(type === "[object Function]") {
+    context = context();
+  }
+
+  if(context === true) {
+    return fn(this);
+  } else if(context === false || context == null) {
+    return inverse(this);
+  } else if(type === "[object Array]") {
+    if(context.length > 0) {
+      for(var i=0, j=context.length; i<j; i++) {
+        ret = ret + fn(context[i]);
+      }
+    } else {
+      ret = inverse(this);
+    }
+    return ret;
+  } else {
+    return fn(context);
+  }
+});
+
+Handlebars.registerHelper('each', function(context, options) {
+  var fn = options.fn, inverse = options.inverse;
+  var ret = "";
+
+  if(context && context.length > 0) {
+    for(var i=0, j=context.length; i<j; i++) {
+      ret = ret + fn(context[i]);
+    }
+  } else {
+    ret = inverse(this);
+  }
+  return ret;
+});
+
+Handlebars.registerHelper('if', function(context, options) {
+  if(!context || Handlebars.Utils.isEmpty(context)) {
+    return options.inverse(this);
+  } else {
+    return options.fn(this);
+  }
+});
+
+Handlebars.registerHelper('unless', function(context, options) {
+  var fn = options.fn, inverse = options.inverse;
+  options.fn = inverse;
+  options.inverse = fn;
+
+  return Handlebars.helpers['if'].call(this, context, options);
+});
+
+Handlebars.registerHelper('with', function(context, options) {
+  return options.fn(context);
+});
+
+Handlebars.logger = {
+  DEBUG: 0, INFO: 1, WARN: 2, ERROR: 3, level: 3,
+
+  // override in the host environment
+  log: function(level, str) {}
+};
+
+Handlebars.log = function(level, str) { Handlebars.logger.log(level, str); };
+
+// END(BROWSER)
+
+module.exports = Handlebars;
+