guard-templates 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in guard-templates.gemspec
+gemspec

data/README.md

@@ -0,0 +1,152 @@
+# Guard::Templates
+
+Guard::Templates is a [Guard](https://github.com/guard/guard) plugin that pre-compiles or translates your project's JS-language templates into include-ready Javascript files.
+
+## Installation
+If using Bundler, just add guard-templates to your Gemfile
+
+```ruby
+group :development do
+  gem 'guard-templates'
+end
+```
+
+Alternatively, install it system-wide with 
+
+```
+gem install guard-templates
+```
+
+Guard::Templates uses [ExecJS](https://github.com/sstephenson/execjs) for intermediary-stage compilation. You can install one of several JS engines and JSON libraries that it will use - see the ExecJS documentation for details. Presently, this is only necessary if you want to transform your Jade templates into precompiled functions.
+
+## Usage
+Once guard-templates is installed you can add a sample Guardfile with:
+
+```
+guard init templates
+```
+
+This will look something like:
+
+```ruby
+guard 'templates', :output => 'public/javascript/templates.js', :namespace => 'MyApp' do
+  watch(/app\/javascripts\/templates\/(.*)\.jade$/)
+end
+```
+
+Change the watch and output paths to match your application, and run 
+
+```
+guard&
+```
+
+## Options
+
+```namespace``` Set to your application's namespace, defaults to 'this'. Use this to keep your templates out of the global scope like a good Javascript citizen. 
+```output``` Path relative to Guard where the compiled Javascript files will be output. If this is a filename ending in .js, all of the templates will be attached to a single object, as above.
+
+### Template Languages Without Precompiling Support
+Presently, aside from Jade, this means all of them. :-) See adding new languages below if you'd like support precompilation for your favorite Javascript templating language.
+
+With a templates directory that looks like:
+
+```
+templates/
+├── foo
+│   └── bar.handlebars
+└── index.handlebars
+```
+
+Then ```:output => 'public/javascripts``` will produce a public/javascripts that looks like:
+
+```
+public/
+└── javascripts
+    ├── foo
+    │   └── bar.js
+    └── index.js
+```
+
+Each file contains the stringified template contents of the handlebars file:
+
+```javascript
+MyApp['index'] = "<div>{{index}}</div>\n"
+```
+
+If output is a path ending in .js, the templates will be compiled to an object in that file. Using the example above with ```:output => 'public/javascripts/templates.js'```, we get a single file result:
+
+```
+public/
+└── javascripts
+    └── templates.js
+```
+
+that looks like:
+
+```javascript
+MyApp.templates = {
+  "index": "<div>{{index}}</div>\n",
+  "foo/bar": "<p>{{example}}</p>\n"
+}
+```
+
+### With Precompiling Jade
+Templates with a .jade extension will be precompiled with Jade's compiler and turned into anonymous functions. The only difference between precompiled and unprecompiled templates is the precompiled ones get turned into functions rather than strings in the resulting Javascript.
+
+With this filesystem structure, and a watch pattern like ```watch(/templates\/(.*)\.jade$/)```
+
+```
+templates/
+├── foo
+│   └── other.jade
+└── index.jade
+```
+
+```:output => 'public/javascripts/templates.js'``` will produce a templates.js that looks like:
+
+```javascript
+MyApp.templates = {
+  "foo/other": function anonymous(locals, attrs, escape, rethrow) {
+    //function contents
+  },
+  "index": function anonymous(locals, attrs, escape, rethrow) {
+    // function contents
+  }
+}
+```
+
+You can then include templates.js in your application and render the templates by calling the functions in question. I.e:
+
+```javascript
+MyApp.templates['foo/other']()
+```
+
+With ```:output => 'public/javascripts'```, each .jade file will be compiled to an individual .js file, like so:
+
+```
+├── public
+│   └── javascripts
+│       ├── foo
+│       │   └── other.js
+│       └── index.js
+├── templates
+│   ├── foo
+│   │   └── other.jade
+│   └── index.jade
+```
+
+With the contents of each compiled js file looking like:
+
+```javascript
+MyApp['index'] = function anonymous(locals, attrs, escape, rethrow) {
+  //function contents
+}
+```
+
+## Precompilation 
+Currently, only [Jade](https://github.com/visionmedia/jade) is supported. All other template types fall back to being inlined as string literals.
+
+### Adding Precompilation Support For Other Languages
+Adding precompilation support for your favorite language is as simple as adding a single class method to Guard::Templates::Compilers. When checking for precompilation support for a particular file extension, guard-templates looks for a class method named ```compile_<extension>``` in that module. It should accept a string (representing the template source) and return a stringified Javascript function. See ```compile_jade``` in Guard::Templates::Compilers for an example.
+
+

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/guard-templates.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+Gem::Specification.new do |s|
+  s.name        = "guard-templates"
+  s.version     = "0.0.1"
+  s.authors     = ["Thomas Mayfield"]
+  s.email       = ["Thomas.Mayfield@gmail.com"]
+  s.homepage    = ""
+  s.summary     = "Javascript template compilation via Guard"
+  s.description = "Guard plugin for smart, automatic compilation of your Javascript template files into usable Javascript"
+
+  s.rubyforge_project = "guard-templates"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_path = "lib"
+
+  s.add_runtime_dependency "guard"
+  s.add_runtime_dependency "execjs"
+  s.add_runtime_dependency "json"
+  s.add_development_dependency "bundler"
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "fakefs"
+end

data/lib/engines/jade-runtime.js

@@ -0,0 +1,123 @@
+
+var jade = (function(exports){
+/*!
+ * Jade - runtime
+ * Copyright(c) 2010 TJ Holowaychuk <tj@vision-media.ca>
+ * MIT Licensed
+ */
+
+/**
+ * Lame Array.isArray() polyfill for now.
+ */
+
+if (!Array.isArray) {
+  Array.isArray = function(arr){
+    return '[object Array]' == Object.prototype.toString.call(arr);
+  };
+}
+
+/**
+ * Lame Object.keys() polyfill for now.
+ */
+
+if (!Object.keys) {
+  Object.keys = function(obj){
+    var arr = [];
+    for (var key in obj) {
+      if (obj.hasOwnProperty(key)) {
+        arr.push(key);
+      }
+    }
+    return arr;
+  } 
+}
+
+/**
+ * Render the given attributes object.
+ *
+ * @param {Object} obj
+ * @return {String}
+ * @api private
+ */
+
+exports.attrs = function attrs(obj){
+  var buf = []
+    , terse = obj.terse;
+  delete obj.terse;
+  var keys = Object.keys(obj)
+    , len = keys.length;
+  if (len) {
+    buf.push('');
+    for (var i = 0; i < len; ++i) {
+      var key = keys[i]
+        , val = obj[key];
+      if ('boolean' == typeof val || null == val) {
+        if (val) {
+          terse
+            ? buf.push(key)
+            : buf.push(key + '="' + key + '"');
+        }
+      } else if ('class' == key && Array.isArray(val)) {
+        buf.push(key + '="' + exports.escape(val.join(' ')) + '"');
+      } else {
+        buf.push(key + '="' + exports.escape(val) + '"');
+      }
+    }
+  }
+  return buf.join(' ');
+};
+
+/**
+ * Escape the given string of `html`.
+ *
+ * @param {String} html
+ * @return {String}
+ * @api private
+ */
+
+exports.escape = function escape(html){
+  return String(html)
+    .replace(/&(?!\w+;)/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;');
+};
+
+/**
+ * Re-throw the given `err` in context to the
+ * the jade in `filename` at the given `lineno`.
+ *
+ * @param {Error} err
+ * @param {String} filename
+ * @param {String} lineno
+ * @api private
+ */
+
+exports.rethrow = function rethrow(err, filename, lineno){
+  if (!filename) throw err;
+
+  var context = 3
+    , str = require('fs').readFileSync(filename, 'utf8')
+    , lines = str.split('\n')
+    , start = Math.max(lineno - context, 0)
+    , end = Math.min(lines.length, lineno + context); 
+
+  // Error context
+  var context = lines.slice(start, end).map(function(line, i){
+    var curr = i + start + 1;
+    return (curr == lineno ? '  > ' : '    ')
+      + curr
+      + '| '
+      + line;
+  }).join('\n');
+
+  // Alter exception message
+  err.path = filename;
+  err.message = (filename || 'Jade') + ':' + lineno 
+    + '\n' + context + '\n\n' + err.message;
+  throw err;
+};
+
+  return exports;
+
+})({});