handlebars 0.0.2 → 0.2.0

data/vendor/handlebars/Rakefile

@@ -0,0 +1,116 @@
+require "rubygems"
+require "bundler/setup"
+
+def compile_parser
+  system "jison src/handlebars.yy src/handlebars.l"
+  if $?.success?
+    File.open("lib/handlebars/compiler/parser.js", "w") do |file|
+      file.puts File.read("handlebars.js") + ";"
+    end
+
+    sh "rm handlebars.js"
+  else
+    puts "Failed to run Jison."
+  end
+end
+
+file "lib/handlebars/compiler/parser.js" => ["src/handlebars.yy","src/handlebars.l"] do
+  if ENV['PATH'].split(':').any? {|folder| File.exists?(folder+'/jison')}
+    compile_parser
+  else
+    puts "Jison is not installed. Trying `npm install jison`."
+    sh "npm install jison -g"
+    compile_parser
+  end
+end
+
+task :compile => "lib/handlebars/compiler/parser.js"
+
+desc "run the spec suite"
+task :spec => [:release] do
+  system "rspec -cfs spec"
+end
+
+task :default => [:compile, :spec]
+
+def remove_exports(string)
+  match = string.match(%r{^// BEGIN\(BROWSER\)\n(.*)\n^// END\(BROWSER\)}m)
+  match ? match[1] : string
+end
+
+minimal_deps = %w(base compiler/parser compiler/base compiler/ast utils compiler/compiler runtime).map do |file|
+  "lib/handlebars/#{file}.js"
+end
+
+runtime_deps = %w(base utils runtime).map do |file|
+  "lib/handlebars/#{file}.js"
+end
+
+directory "dist"
+
+minimal_deps.unshift "dist"
+
+def build_for_task(task)
+  FileUtils.rm_rf("dist/*") if File.directory?("dist")
+  FileUtils.mkdir_p("dist")
+
+  contents = []
+  task.prerequisites.each do |filename|
+    next if filename == "dist"
+
+    contents << "// #{filename}\n" + remove_exports(File.read(filename)) + ";"
+  end
+
+  File.open(task.name, "w") do |file|
+    file.puts contents.join("\n")
+  end
+end
+
+file "dist/handlebars.js" => minimal_deps do |task|
+  build_for_task(task)
+end
+
+file "dist/handlebars.runtime.js" => runtime_deps do |task|
+  build_for_task(task)
+end
+
+task :build => [:compile, "dist/handlebars.js"]
+task :runtime => [:compile, "dist/handlebars.runtime.js"]
+
+desc "build the build and runtime version of handlebars"
+task :release => [:build, :runtime]
+
+directory "vendor"
+
+desc "benchmark against dust.js and mustache.js"
+task :bench => "vendor" do
+  require "open-uri"
+  #File.open("vendor/mustache.js", "w") do |file|
+    #file.puts open("https://github.com/janl/mustache.js/raw/master/mustache.js").read
+    #file.puts "module.exports = Mustache;"
+  #end
+
+  File.open("vendor/benchmark.js", "w") do |file|
+    file.puts open("https://raw.github.com/bestiejs/benchmark.js/master/benchmark.js").read
+  end
+
+  #if File.directory?("vendor/dustjs")
+    #system "cd vendor/dustjs && git pull"
+  #else
+    #system "git clone git://github.com/akdubya/dustjs.git vendor/dustjs"
+  #end
+
+  #if File.directory?("vendor/coffee")
+    #system "cd vendor/coffee && git pull"
+  #else
+    #system "git clone git://github.com/jashkenas/coffee-script.git vendor/coffee"
+  #end
+
+  #if File.directory?("vendor/eco")
+    #system "cd vendor/eco && git pull && npm update"
+  #else
+    #system "git clone git://github.com/sstephenson/eco.git vendor/eco && cd vendor/eco && npm update"
+  #end
+
+  system "node bench/handlebars.js"
+end

data/vendor/handlebars/bench/benchwarmer.js

@@ -0,0 +1,149 @@
+
+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");
+            }
+          }
+        }
+      }
+    });
+
+    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/vendor/handlebars/bench/handlebars.js

@@ -0,0 +1,163 @@
+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) {
+  return ecoExports(str);
+}
+
+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/vendor/handlebars/bin/handlebars

@@ -0,0 +1,139 @@
+#!/usr/bin/env node
+
+var optimist = require('optimist')
+    .usage('Precompile handlebar templates.\nUsage: $0 template...', {
+      'f': {
+        'type': 'string',
+        'description': 'Output File',
+        'alias': 'output'
+      },
+      'k': {
+        'type': 'string',
+        'description': 'Known helpers',
+        'alias': 'known'
+      },
+      'o': {
+        'type': 'boolean',
+        'description': 'Known helpers only',
+        'alias': 'knownOnly'
+      },
+      'm': {
+        'type': 'boolean',
+        'description': 'Minimize output',
+        'alias': 'min'
+      },
+      's': {
+        'type': 'boolean',
+        'description': 'Output template function only.',
+        'alias': 'simple'
+      },
+      'r': {
+        'type': 'string',
+        'description': 'Template root. Base value that will be stripped from template names.',
+        'alias': 'root'
+      }
+    })
+
+    .check(function(argv) {
+      var template = [0];
+      if (!argv._.length) {
+        throw 'Must define at least one template or directory.';
+      }
+
+      argv._.forEach(function(template) {
+        try {
+          fs.statSync(template);
+        } catch (err) {
+          throw 'Unable to open template file "' + template + '"';
+        }
+      });
+    })
+    .check(function(argv) {
+      if (argv.simple && argv.min) {
+        throw 'Unable to minimze simple output';
+      }
+      if (argv.simple && (argv._.length !== 1 || fs.statSync(argv._[0]).isDirectory())) {
+        throw 'Unable to output multiple templates in simple mode';
+      }
+    });
+
+var fs = require('fs'),
+    handlebars = require('../lib/handlebars'),
+    basename = require('path').basename,
+    uglify = require('uglify-js');
+
+var argv = optimist.argv,
+    template = argv._[0];
+
+// Convert the known list into a hash
+var known = {};
+if (argv.known && !Array.isArray(argv.known)) {
+  argv.known = [argv.known];
+}
+if (argv.known) {
+  for (var i = 0, len = argv.known.length; i < len; i++) {
+    known[argv.known[i]] = true;
+  }
+}
+
+var output = [];
+if (!argv.simple) {
+  output.push('(function() {\n  var template = Handlebars.template, templates = Handlebars.templates = Handlebars.templates || {};\n');
+}
+function processTemplate(template, root) {
+  var path = template,
+      stat = fs.statSync(path);
+  if (stat.isDirectory()) {
+    fs.readdirSync(template).map(function(file) {
+      var path = template + '/' + file;
+
+      if (/\.handlebars$/.test(path) || fs.statSync(path).isDirectory()) {
+        processTemplate(path, root || template);
+      }
+    });
+  } else {
+    var data = fs.readFileSync(path, 'utf8');
+
+    var options = {
+      knownHelpers: known,
+      knownHelpersOnly: argv.o
+    };
+
+    // Clean the template name
+    if (!root) {
+      template = basename(template);
+    } else if (template.indexOf(root) === 0) {
+      template = template.substring(root.length+1);
+    }
+    template = template.replace(/\.handlebars$/, '');
+
+    if (argv.simple) {
+      output.push(handlebars.precompile(data, options) + '\n');
+    } else {
+      output.push('templates[\'' + template + '\'] = template(' + handlebars.precompile(data, options) + ');\n');
+    }
+  }
+}
+
+argv._.forEach(function(template) {
+  processTemplate(template, argv.root);
+});
+
+// Output the content
+if (!argv.simple) {
+  output.push('})();');
+}
+output = output.join('');
+
+if (argv.min) {
+  var ast = uglify.parser.parse(output);
+  ast = uglify.uglify.ast_mangle(ast);
+  ast = uglify.uglify.ast_squeeze(ast);
+  output = uglify.uglify.gen_code(ast);
+}
+
+if (argv.output) {
+  fs.writeFileSync(argv.output, output, 'utf8');
+} else {
+  console.log(output);
+}