jader 0.0.3 → 0.0.4

data/.gitignore

@@ -6,3 +6,5 @@ pkg/*
 .rvmrc
 *.sqlite
 spec/dummy/tmp/
+doc/
+.yardoc

data/README.md

@@ -43,7 +43,7 @@ The most significant differences between using standard server-side Ruby-based e
 
 Our template code should look like this:
 
-```
+```jade
 ul.users
   each user in users
     li.user= user.name
@@ -58,7 +58,7 @@ Since Rails doesn't expect server-side templates to live under `app/assets` we n
 
 Inside your `application_controller.rb` add the following:
 
-```
+```ruby
 class ApplicationController < ActionController::Base
   protect_from_forgery
 
@@ -131,7 +131,7 @@ Jader does not assume your Rails models should be serialized by default. Instead
 
 To enable this behaviour, consider the following example:
 
-```
+```ruby
 class User < ActiveRecord::Base
 
   include Jader::Serialize
@@ -149,7 +149,7 @@ By default, calling `jade_serializable` with no arguments will serialize all you
 
 Consider the following code:
 
-```
+```ruby
 # define our model
 class User < ActiveRecord::Base
 
@@ -180,7 +180,7 @@ which attributes should always be serialized, and whether we'd like these attrib
 Consider the following code:
 
 
-```
+```ruby
 # define our models
 
 class Favorite < ActiveRecord::Base
@@ -221,7 +221,7 @@ To only serialize the specified attributes, call `jade_serializable` with `:merg
 
 Invokation format for `jade_serializable` is:
 
-```
+```ruby
 jade_serializable :attr1, :attr2, :attr3 ...., :merge => true/false
 ```
 
@@ -284,7 +284,7 @@ For the sake of this example, we assume `gem 'i18n-js'` is installed in our appl
 
 Our `application.js` file will then include:
 
-```
+``` javascript
 //= require i18n
 //= require i18n/translations
 ```
@@ -332,7 +332,7 @@ Jader is built upon the wonderful work of [Boris Staal](https://github.com/round
   - [ruby-haml-js](https://github.com/dnagir/ruby-haml-js)
   - [tilt-jade](https://github.com/therabidbanana/tilt-jade)
   
-Boris Staal's Jade Rubygem It was developed as a successor to tilt-jade to improve following:
+Boris Staal's [Jade](https://github.com/roundlake/jade/) Rubygem was developed as a successor to tilt-jade to improve following:
 
   * Add debugging capabilities (slightly different build technique)
   * Support exact Jade.JS lib without modifications

data/jader.gemspec

@@ -18,11 +18,12 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_dependency 'execjs'
+  s.add_dependency 'libv8'
   s.add_dependency 'tilt'
   s.add_dependency 'sprockets'
   s.add_development_dependency 'rspec'
   s.add_development_dependency 'rspec-rails'
   s.add_development_dependency 'rails', '>= 3.1'
   s.add_development_dependency 'pry'
+  s.add_development_dependency 'yard'
 end

data/lib/jader/compiler.rb

@@ -1,9 +1,13 @@
-require 'execjs'
+require 'v8'
 
 module Jader
   class Compiler
     attr_accessor :options
 
+    # Initialize Jader template compiler. @see https://github.com/visionmedia/jade#options
+    # @param [Hash] options Jade compiler options
+    # @option options [Boolean] :client run Jade compiler in client / server mode (default `true`)
+    # @option options [Boolean] :compileDebug run Jade compiler in debug mode(default `false`)
     def initialize(options={})
       @options = {
         :client => true,
@@ -11,6 +15,8 @@ module Jader
       }.merge options
     end
 
+    # Jade template engine Javascript source code used to compile templates in ExecJS
+    # @return [String] Jade source code
     def source
       @source ||= %{
         var window = {};
@@ -19,40 +25,63 @@ module Jader
       }
     end
 
-    def context
-      @context ||= ExecJS.compile source
+    # V8 context with Jade code compiled
+    # @yield [context] V8::Context compiled Jade source code in V8 context
+    def v8_context
+      V8::C::Locker() do
+        context = V8::Context.new
+        context.eval(source)
+        yield context
+      end
     end
 
+    # Jade Javascript engine version
+    # @return [String] version of Jade javascript engine installed in `vendor/assets/javascripts`
     def jade_version
-      context.eval("jade.version")
+      v8_context do |context|
+        context.eval("jade.version")
+      end
     end
 
+    # Compile a Jade template for client-side use with JST
+    # @param [String, File] template Jade template file or text to compile
+    # @param [String] file_name name of template file used to resolve mixins inclusion
+    # @return [String] Jade template compiled into Javascript and wrapped inside an anonymous function for JST
     def compile(template, file_name = '')
-      template = template.read if template.respond_to?(:read)
-      file_name.match(/views\/([^\/]+)\//)
-      controller_name = $1 || nil
-      combo = (template_mixins(controller_name) << template).join("\n").to_json
-      tmpl = context.eval("jade.precompile(#{combo}, #{@options.to_json})")
-
-      %{
-        function(locals){
-          #{tmpl}
-        }
-      }
+      v8_context do |context|
+        template = template.read if template.respond_to?(:read)
+        file_name.match(/views\/([^\/]+)\//)
+        controller_name = $1 || nil
+        combo = (template_mixins(controller_name) << template).join("\n").to_json
+        context.eval("jade.compile(#{combo},#{@options.to_json})").to_s.sub('function anonymous','function')
+      end
     end
 
+    # Compile and evaluate a Jade template for server-side rendering
+    # @param [String] template Jade template text to render
+    # @param [String] controller_name name of Rails controller that's rendering the template
+    # @param [Hash] vars controller instance variables passed to the template
+    # @return [String] HTML output of compiled Jade template
     def render(template, controller_name, vars = {})
-      combo = (template_mixins(controller_name) << template).join("\n").to_json
-      tmpl = context.eval("jade.precompile(#{combo}, #{@options.to_json})")
-      context.eval(%{
-        function(locals){
-          #{Jader::Source::runtime}
-          #{Jader.configuration.includes.join("\n")}
-          #{tmpl}
-        }.call(null,#{vars.to_jade.to_json})
-      })
+      v8_context do |context|
+        context.eval(Jader.configuration.includes.join("\n"))
+        combo = (template_mixins(controller_name) << template).join("\n").to_json
+        context.eval("var fn = jade.compile(#{combo})")
+        context.eval("fn(#{vars.to_jade.to_json})")
+      end
+      #tmpl = context.eval("jade.precompile(#{combo}, #{@options.to_json})")
+      #context.eval(%{
+      #  function(locals){
+      #    #{Jader::Source::runtime}
+      #    #{Jader.configuration.includes.join("\n")}
+      #    #{tmpl}
+      #  }.call(null,#{vars.to_jade.to_json})
+      #})
     end
 
+    # Jade template mixins for a given controller
+    # @param [String] controller_name name of Rails controller rendering a Jade template
+    # @return [Array<String>] array of Jade mixins to use with a Jade template rendered by a Rails controller
     def template_mixins(controller_name)
       mixins = []
       unless Jader.configuration.mixins_path.nil?

data/lib/jader/configuration.rb

@@ -3,14 +3,23 @@ module Jader
     attr_accessor :configuration
   end
 
+  # Configure Jader
+  # @yield [config] Jader::Configuration instance
+  # @example
+  #     Jader.configure do |config|
+  #       config.mixins_path = Rails.root.join('app','assets','javascripts','helpers')
+  #       config.includes << IO.read Rails.root.join('app','assets','javascripts','util.js')
+  #     end
   def self.configure
     self.configuration ||= Configuration.new
     yield(configuration)
   end
 
+  # Jader configuration class
   class Configuration
     attr_accessor :mixins_path, :includes
 
+    # Initialize Jader::Configuration class with default values
     def initialize
       @mixins_path = nil
       @includes = []

data/lib/jader/renderer.rb

@@ -1,11 +1,22 @@
 module Jader
+  # Server side Jade templates renderer
   module Renderer
 
+    # Convert Jade template to HTML output for rendering as a Rails view
+    # @param [String] template_text Jade template text to convert
+    # @param [String] controller_name name of Rails controller rendering the view
+    # @param [Hash] vars controller instance variables passed to the template
+    # @return [String] HTML output of evaluated template
+    # @see Jader::Compiler#render
     def self.convert_template(template_text, controller_name, vars = {})
       compiler = Jader::Compiler.new :client => true
       compiler.render(template_text, controller_name, vars)
     end
 
+    # Prepare controller instance variables for the template and execute template conversion.
+    # Called as an ActionView::Template registered template
+    # @param [ActionView::Template] template currently rendered ActionView::Template instance
+    # @see Jader::Renderer#convert_template
     def self.call(template)
       template.source.gsub!(/\#\{([^\}]+)\}/,"\\\#{\\1}") # escape Jade's #{somevariable} syntax
       %{

data/lib/jader/serialize.rb

@@ -4,6 +4,15 @@ module Jader
 
     module ClassMethods
 
+      # Enable serialization on ActiveModel classes
+      # @param [Array<Symbol>] args model attribute names to serialize
+      # @param [Hash] args options serializing mode
+      # @option args [Boolean] :merge should serialized attributes be merged with `self.attributes`
+      # @example
+      #     class User < ActiveRecord::Base
+      #       include Jader::Serialize
+      #       jade_serializable :name, :email, :merge => false
+      #     end
       def jade_serializable(*args)
         serialize = {
           :attrs => [],
@@ -21,10 +30,23 @@ module Jader
 
     end
 
+    #nodoc
     def self.included(base)
       base.extend ClassMethods
     end
 
+    # Serialize instance attributes to a Hash based on serializable attributes defined on Model class.
+    # @return [Hash] hash of model instance attributes
+    def to_jade
+      h = {:model => self.class.name.downcase}
+      self.jade_attributes.each do |attr|
+        h[attr] = self.send(attr)
+      end
+      h
+    end
+
+    # List of Model attributes that should be serialized when called `to_jade` on Model instance
+    # @return [Array] list of serializable attributes
     def jade_attributes
       s = self.class.class_variable_get(:@@serialize)
       if s[:merge]
@@ -34,20 +56,12 @@ module Jader
       end
       attrs.collect{|attr| attr.to_sym}.uniq
     end
-
-    def to_jade
-      h = {:model => self.class.name.downcase}
-      self.jade_attributes.each do |attr|
-        h[attr] = self.send(attr)
-      end
-      h
-    end
-
   end
 
 end
 
 class Object
+  # Serialize Object to Jade format. Invoke `self.to_jade` if instance responds to `to_jade`
   def to_ice
     if self.respond_to? :to_a
       self.to_a.to_jade
@@ -57,6 +71,7 @@ class Object
   end
 end
 
+#nodoc
 [FalseClass, TrueClass, Numeric, String].each do |cls|
   cls.class_eval do
     def to_jade
@@ -66,12 +81,16 @@ end
 end
 
 class Array
+
+  # Serialize Array to Jade format. Invoke `to_jade` on array members
   def to_jade
     map {|a| a.respond_to?(:to_jade) ? a.to_jade : a }
   end
 end
 
 class Hash
+
+  # Serialize Hash to Jade format. Invoke `to_jade` on members
   def to_jade
     res = {}
     each_pair do |key, value|

data/lib/jader/source.rb

@@ -1,17 +1,23 @@
 module Jader
+  # Jade template engine Javascript source code
   module Source
+
+    # Jade source code
     def self.jade
       IO.read jade_path
     end
 
+    # Jade runtime source code
     def self.runtime
       IO.read runtime_path
     end
 
+    # Jade source code path
     def self.jade_path
       File.expand_path("../../../vendor/assets/javascripts/jade/jade.js", __FILE__)
     end
 
+    # Jade runtime source code path
     def self.runtime_path
       File.expand_path("../../../vendor/assets/javascripts/jade/runtime.js", __FILE__)
     end

data/lib/jader/template.rb

@@ -1,27 +1,26 @@
 require 'tilt/template'
 
 module Jader
+  # Jader Tilt template for use with JST
   class Template < Tilt::Template
     self.default_mime_type = 'application/javascript'
 
+    # Ensure V8 is available when engine is initialized
     def self.engine_initialized?
-      defined? ::ExecJS
+      defined? ::V8
     end
 
+    # Require 'execjs' when initializing engine
     def initialize_engine
-      require_template_library 'execjs'
+      require_template_library 'v8'
     end
 
     def prepare
     end
 
+    # Evaluate the template. Compiles the template for JST
+    # @return [String] JST-compliant compiled version of the Jade template being rendered
     def evaluate(scope, locals, &block)
-      compile_function
-    end
-
-  private
-
-    def compile_function
       Jader::Compiler.new(:filename => file).compile(data, file)
     end
 

data/lib/jader/version.rb

@@ -1,3 +1,3 @@
 module Jader
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

data/spec/compiler_spec.rb

@@ -12,12 +12,14 @@ describe Jader::Compiler do
     }
   end
 
-  it "should contain ExecJS context" do
-    @compiler.context.eval("window.jade").should_not be_empty
+  it "should contain v8 context" do
+    @compiler.v8_context do |context|
+      context.eval("typeof window.jade").should == 'object'
+    end
   end
 
   it "should define Jade.JS compiler version" do
-    @compiler.jade_version.should == "0.20.0"
+    @compiler.jade_version.should == "0.27.2"
   end
 
   it "should compile small thing" do

data/spec/template_spec.rb

@@ -21,16 +21,18 @@ describe Jader::Compiler do
   end
 
   it 'should work fine with JST' do
-    context = ExecJS.compile %{
+    context = V8::Context.new
+    context.eval %{
       #{asset_for('application.js').to_s}
       html = JST['sample']({name: 'Yorik'})
     }
-    context.eval('html').should == "<!DOCTYPE html><head><title>Hello, Yorik :)</title></head><body>Yap, it works\n</body>"
+    context.eval('html').should == "<!DOCTYPE html><head><title>Hello, Yorik :)</title></head><body>Yap, it works</body>"
   end
 
   it 'should use mixins in JST' do
     phrase = 'Hi There'
-    context = ExecJS.compile %{
+    context = V8::Context.new
+    context.eval %{
       #{asset_for('application.js').to_s}
       html = JST['views/users/index']({phrase: '#{phrase}'})
     }

data/vendor/assets/javascripts/jade/jade.js

@@ -30,7 +30,7 @@ require.register = function (path, fn){
 
 require.relative = function (parent) {
     return function(p){
-      if ('.' != p[0]) return require(p);
+      if ('.' != p.charAt(0)) return require(p);
       
       var path = parent.split('/')
         , segs = p.split('/');
@@ -63,10 +63,10 @@ var nodes = require('./nodes')
   , filters = require('./filters')
   , doctypes = require('./doctypes')
   , selfClosing = require('./self-closing')
-  , inlineTags = require('./inline-tags')
+  , runtime = require('./runtime')
   , utils = require('./utils');
 
- 
+
  if (!Object.keys) {
    Object.keys = function(obj){
      var arr = [];
@@ -76,9 +76,9 @@ var nodes = require('./nodes')
        }
      }
      return arr;
-   } 
+   }
  }
- 
+
  if (!String.prototype.trimLeft) {
    String.prototype.trimLeft = function(){
      return this.replace(/^\s+/, '');
@@ -103,6 +103,7 @@ var Compiler = module.exports = function Compiler(node, options) {
   this.pp = options.pretty || false;
   this.debug = false !== options.compileDebug;
   this.indents = 0;
+  this.parentIndents = 0;
   if (options.doctype) this.setDoctype(options.doctype);
 };
 
@@ -111,16 +112,17 @@ var Compiler = module.exports = function Compiler(node, options) {
  */
 
 Compiler.prototype = {
-  
+
   /**
    * Compile parse tree to JavaScript.
    *
    * @api public
    */
-  
+
   compile: function(){
     this.buf = ['var interp;'];
-    this.lastBufferedIdx = -1
+    if (this.pp) this.buf.push("var __indent = [];");
+    this.lastBufferedIdx = -1;
     this.visit(this.node);
     return this.buf.join('\n');
   },
@@ -133,15 +135,14 @@ Compiler.prototype = {
    * @param {string} name
    * @api public
    */
-  
+
   setDoctype: function(name){
-    var doctype = doctypes[(name || 'default').toLowerCase()];
-    doctype = doctype || '<!DOCTYPE ' + name + '>';
-    this.doctype = doctype;
-    this.terse = '5' == name || 'html' == name;
+    name = (name && name.toLowerCase()) || 'default';
+    this.doctype = doctypes[name] || '<!DOCTYPE ' + name + '>';
+    this.terse = this.doctype.toLowerCase() == '<!doctype html>';
     this.xml = 0 == this.doctype.indexOf('<?xml');
   },
-  
+
   /**
    * Buffer the given `str` optionally escaped.
    *
@@ -149,10 +150,10 @@ Compiler.prototype = {
    * @param {Boolean} esc
    * @api public
    */
-  
+
   buffer: function(str, esc){
     if (esc) str = utils.escape(str);
-    
+
     if (this.lastBufferedIdx == this.buf.length) {
       this.lastBuffered += str;
       this.buf[this.lastBufferedIdx - 1] = "buf.push('" + this.lastBuffered + "');"
@@ -160,23 +161,40 @@ Compiler.prototype = {
       this.buf.push("buf.push('" + str + "');");
       this.lastBuffered = str;
       this.lastBufferedIdx = this.buf.length;
-    }    
+    }
   },
-  
+
+  /**
+   * Buffer an indent based on the current `indent`
+   * property and an additional `offset`.
+   *
+   * @param {Number} offset
+   * @param {Boolean} newline
+   * @api public
+   */
+
+  prettyIndent: function(offset, newline){
+    offset = offset || 0;
+    newline = newline ? '\\n' : '';
+    this.buffer(newline + Array(this.indents + offset).join('  '));
+    if (this.parentIndents)
+      this.buf.push("buf.push.apply(buf, __indent);");
+  },
+
   /**
    * Visit `node`.
    *
    * @param {Node} node
    * @api public
    */
-  
+
   visit: function(node){
     var debug = this.debug;
 
     if (debug) {
       this.buf.push('__jade.unshift({ lineno: ' + node.line
         + ', filename: ' + (node.filename
-          ? '"' + node.filename + '"'
+          ? JSON.stringify(node.filename)
           : '__jade[0].filename')
         + ' });');
     }
@@ -192,14 +210,14 @@ Compiler.prototype = {
 
     if (debug) this.buf.push('__jade.shift();');
   },
-  
+
   /**
    * Visit `node`.
    *
    * @param {Node} node
    * @api public
    */
-  
+
   visitNode: function(node){
     var name = node.constructor.name
       || node.constructor.toString().match(/function ([^(\s]+)()/)[1];
@@ -221,7 +239,7 @@ Compiler.prototype = {
     this.buf.push('}');
     this.withinCase = _;
   },
-  
+
   /**
    * Visit when `node`.
    *
@@ -259,12 +277,34 @@ Compiler.prototype = {
    */
 
   visitBlock: function(block){
-    var len = block.nodes.length;
+    var len = block.nodes.length
+      , escape = this.escape
+      , pp = this.pp
+
+    // Block keyword has a special meaning in mixins
+    if (this.parentIndents && block.mode) {
+      if (pp) this.buf.push("__indent.push('" + Array(this.indents + 1).join('  ') + "');")
+      this.buf.push('block && block();');
+      if (pp) this.buf.push("__indent.pop();")
+      return;
+    }
+
+    // Pretty print multi-line text
+    if (pp && len > 1 && !escape && block.nodes[0].isText && block.nodes[1].isText)
+      this.prettyIndent(1, true);
+
     for (var i = 0; i < len; ++i) {
+      // Pretty print text
+      if (pp && i > 0 && !escape && block.nodes[i].isText && block.nodes[i-1].isText)
+        this.prettyIndent(1, false);
+
       this.visit(block.nodes[i]);
+      // Multiple text nodes are separated by newlines
+      if (block.nodes[i+1] && block.nodes[i].isText && block.nodes[i+1].isText)
+        this.buffer('\\n');
     }
   },
-  
+
   /**
    * Visit `doctype`. Sets terse mode to `true` when html 5
    * is used, causing self-closing tags to end with ">" vs "/>",
@@ -273,7 +313,7 @@ Compiler.prototype = {
    * @param {Doctype} doctype
    * @api public
    */
-  
+
   visitDoctype: function(doctype){
     if (doctype && (doctype.val || !this.doctype)) {
       this.setDoctype(doctype.val || 'default');
@@ -293,14 +333,62 @@ Compiler.prototype = {
 
   visitMixin: function(mixin){
     var name = mixin.name.replace(/-/g, '_') + '_mixin'
-      , args = mixin.args || '';
+      , args = mixin.args || ''
+      , block = mixin.block
+      , attrs = mixin.attrs
+      , pp = this.pp;
+
+    if (mixin.call) {
+      if (pp) this.buf.push("__indent.push('" + Array(this.indents + 1).join('  ') + "');")
+      if (block || attrs.length) {
+
+        this.buf.push(name + '.call({');
+
+        if (block) {
+          this.buf.push('block: function(){');
+
+          // Render block with no indents, dynamically added when rendered
+          this.parentIndents++;
+          var _indents = this.indents;
+          this.indents = 0;
+          this.visit(mixin.block);
+          this.indents = _indents;
+          this.parentIndents--;
+
+          if (attrs.length) {
+            this.buf.push('},');
+          } else {
+            this.buf.push('}');
+          }
+        }
 
-    if (mixin.block) {
-      this.buf.push('var ' + name + ' = function(' + args + '){');
-      this.visit(mixin.block);
-      this.buf.push('}');
+        if (attrs.length) {
+          var val = this.attrs(attrs);
+          if (val.inherits) {
+            this.buf.push('attributes: merge({' + val.buf
+                + '}, attributes), escaped: merge(' + val.escaped + ', escaped, true)');
+          } else {
+            this.buf.push('attributes: {' + val.buf + '}, escaped: ' + val.escaped);
+          }
+        }
+
+        if (args) {
+          this.buf.push('}, ' + args + ');');
+        } else {
+          this.buf.push('});');
+        }
+
+      } else {
+        this.buf.push(name + '(' + args + ');');
+      }
+      if (pp) this.buf.push("__indent.pop();")
     } else {
-      this.buf.push(name + '(' + args + ');');
+      this.buf.push('var ' + name + ' = function(' + args + '){');
+      this.buf.push('var block = this.block, attributes = this.attributes || {}, escaped = this.escaped || {};');
+      this.parentIndents++;
+      this.visit(block);
+      this.parentIndents--;
+      this.buf.push('};');
     }
   },
 
@@ -311,10 +399,13 @@ Compiler.prototype = {
    * @param {Tag} tag
    * @api public
    */
-  
+
   visitTag: function(tag){
     this.indents++;
-    var name = tag.name;
+    var name = tag.name
+      , pp = this.pp;
+
+    if (tag.buffer) name = "' + (" + name + ") + '";
 
     if (!this.hasCompiledTag) {
       if (!this.hasCompiledDoctype && 'html' == name) {
@@ -324,11 +415,10 @@ Compiler.prototype = {
     }
 
     // pretty print
-    if (this.pp && inlineTags.indexOf(name) == -1) {
-      this.buffer('\\n' + Array(this.indents).join('  '));
-    }
+    if (pp && !tag.isInline())
+      this.prettyIndent(0, true);
 
-    if (~selfClosing.indexOf(name) && !this.xml) {
+    if ((~selfClosing.indexOf(name) || tag.selfClosing) && !this.xml) {
       this.buffer('<' + name);
       this.visitAttributes(tag.attrs);
       this.terse
@@ -344,27 +434,25 @@ Compiler.prototype = {
         this.buffer('<' + name + '>');
       }
       if (tag.code) this.visitCode(tag.code);
-      if (tag.text) this.buffer(utils.text(tag.text.nodes[0].trimLeft()));
       this.escape = 'pre' == tag.name;
       this.visit(tag.block);
 
       // pretty print
-      if (this.pp && !~inlineTags.indexOf(name) && !tag.textOnly) {
-        this.buffer('\\n' + Array(this.indents).join('  '));
-      }
+      if (pp && !tag.isInline() && 'pre' != tag.name && !tag.canInline())
+        this.prettyIndent(0, true);
 
       this.buffer('</' + name + '>');
     }
     this.indents--;
   },
-  
+
   /**
    * Visit `filter`, throwing when the filter does not exist.
    *
    * @param {Filter} filter
    * @api public
    */
-  
+
   visitFilter: function(filter){
     var fn = filters[filter.name];
 
@@ -376,48 +464,50 @@ Compiler.prototype = {
         throw new Error('unknown filter ":' + filter.name + '"');
       }
     }
+
     if (filter.isASTFilter) {
       this.buf.push(fn(filter.block, this, filter.attrs));
     } else {
-      var text = filter.block.nodes.join('');
+      var text = filter.block.nodes.map(function(node){ return node.val }).join('\n');
+      filter.attrs = filter.attrs || {};
+      filter.attrs.filename = this.options.filename;
       this.buffer(utils.text(fn(text, filter.attrs)));
     }
   },
-  
+
   /**
    * Visit `text` node.
    *
    * @param {Text} text
    * @api public
    */
-  
+
   visitText: function(text){
-    text = utils.text(text.nodes.join(''));
+    text = utils.text(text.val.replace(/\\/g, '\\\\'));
     if (this.escape) text = escape(text);
     this.buffer(text);
-    this.buffer('\\n');
   },
-  
+
   /**
    * Visit a `comment`, only buffering when the buffer flag is set.
    *
    * @param {Comment} comment
    * @api public
    */
-  
+
   visitComment: function(comment){
     if (!comment.buffer) return;
-    if (this.pp) this.buffer('\\n' + Array(this.indents + 1).join('  '));
+    if (this.pp) this.prettyIndent(1, true);
     this.buffer('<!--' + utils.escape(comment.val) + '-->');
   },
-  
+
   /**
    * Visit a `BlockComment`.
    *
    * @param {Comment} comment
    * @api public
    */
-  
+
   visitBlockComment: function(comment){
     if (!comment.buffer) return;
     if (0 == comment.val.trim().indexOf('if')) {
@@ -430,7 +520,7 @@ Compiler.prototype = {
       this.buffer('-->');
     }
   },
-  
+
   /**
    * Visit `code`, respecting buffer / escape flags.
    * If the code is followed by a block, wrap it in
@@ -439,7 +529,7 @@ Compiler.prototype = {
    * @param {Code} code
    * @api public
    */
-  
+
   visitCode: function(code){
     // Wrap code blocks with {}.
     // we only wrap unbuffered code blocks ATM
@@ -463,26 +553,39 @@ Compiler.prototype = {
       if (!code.buffer) this.buf.push('}');
     }
   },
-  
+
   /**
    * Visit `each` block.
    *
    * @param {Each} each
    * @api public
    */
-  
+
   visitEach: function(each){
     this.buf.push(''
       + '// iterate ' + each.obj + '\n'
-      + '(function(){\n'
-      + '  if (\'number\' == typeof ' + each.obj + '.length) {\n'
+      + ';(function(){\n'
+      + '  if (\'number\' == typeof ' + each.obj + '.length) {\n');
+
+    if (each.alternative) {
+      this.buf.push('  if (' + each.obj + '.length) {');
+    }
+
+    this.buf.push(''
       + '    for (var ' + each.key + ' = 0, $$l = ' + each.obj + '.length; ' + each.key + ' < $$l; ' + each.key + '++) {\n'
       + '      var ' + each.val + ' = ' + each.obj + '[' + each.key + '];\n');
 
     this.visit(each.block);
 
+    this.buf.push('    }\n');
+
+    if (each.alternative) {
+      this.buf.push('  } else {');
+      this.visit(each.alternative);
+      this.buf.push('  }');
+    }
+
     this.buf.push(''
-      + '    }\n'
       + '  } else {\n'
       + '    for (var ' + each.key + ' in ' + each.obj + ') {\n'
        + '      if (' + each.obj + '.hasOwnProperty(' + each.key + ')){'
@@ -494,21 +597,43 @@ Compiler.prototype = {
 
     this.buf.push('   }\n  }\n}).call(this);\n');
   },
-  
+
   /**
    * Visit `attrs`.
    *
    * @param {Array} attrs
    * @api public
    */
-  
+
   visitAttributes: function(attrs){
+    var val = this.attrs(attrs);
+    if (val.inherits) {
+      this.buf.push("buf.push(attrs(merge({ " + val.buf +
+          " }, attributes), merge(" + val.escaped + ", escaped, true)));");
+    } else if (val.constant) {
+      eval('var buf={' + val.buf + '};');
+      this.buffer(runtime.attrs(buf, JSON.parse(val.escaped)), true);
+    } else {
+      this.buf.push("buf.push(attrs({ " + val.buf + " }, " + val.escaped + "));");
+    }
+  },
+
+  /**
+   * Compile attributes.
+   */
+
+  attrs: function(attrs){
     var buf = []
-      , classes = [];
+      , classes = []
+      , escaped = {}
+      , constant = attrs.every(function(attr){ return isConstant(attr.val) })
+      , inherits = false;
 
     if (this.terse) buf.push('terse: true');
 
     attrs.forEach(function(attr){
+      if (attr.name == 'attributes') return inherits = true;
+      escaped[attr.name] = attr.escaped;
       if (attr.name == 'class') {
         classes.push('(' + attr.val + ')');
       } else {
@@ -522,12 +647,40 @@ Compiler.prototype = {
       buf.push("class: " + classes);
     }
 
-    buf = buf.join(', ').replace('class:', '"class":');
-
-    this.buf.push("buf.push(attrs({ " + buf + " }));");
+    return {
+      buf: buf.join(', ').replace('class:', '"class":'),
+      escaped: JSON.stringify(escaped),
+      inherits: inherits,
+      constant: constant
+    };
   }
 };
 
+/**
+ * Check if expression can be evaluated to a constant
+ *
+ * @param {String} expression
+ * @return {Boolean}
+ * @api private
+ */
+
+function isConstant(val){
+  // Check strings/literals
+  if (/^ *("([^"\\]*(\\.[^"\\]*)*)"|'([^'\\]*(\\.[^'\\]*)*)'|true|false|null|undefined) *$/i.test(val))
+    return true;
+
+  // Check numbers
+  if (!isNaN(Number(val)))
+    return true;
+
+  // Check arrays
+  var matches;
+  if (matches = /^ *\[(.*)\] *$/.exec(val))
+    return matches[1].split(',').every(isConstant);
+
+  return false;
+}
+
 /**
  * Escape the given string of `html`.
  *
@@ -556,8 +709,8 @@ require.register("doctypes.js", function(module, exports, require){
 
 module.exports = {
     '5': '<!DOCTYPE html>'
+  , 'default': '<!DOCTYPE html>'
   , 'xml': '<?xml version="1.0" encoding="utf-8" ?>'
-  , 'default': '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">'
   , 'transitional': '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">'
   , 'strict': '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">'
   , 'frameset': '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Frameset//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd">'
@@ -661,7 +814,7 @@ module.exports = {
 
   coffeescript: function(str){
     str = str.replace(/\\n/g, '\n');
-    var js = require('coffee-script').compile(str).replace(/\n/g, '\\n');
+    var js = require('coffee-script').compile(str).replace(/\\/g, '\\\\').replace(/\n/g, '\\n');
     return '<script type="text/javascript">\\n' + js + '</script>';
   }
 };
@@ -719,7 +872,7 @@ var Parser = require('./parser')
  * Library version.
  */
 
-exports.version = '0.20.0';
+exports.version = '0.27.2';
 
 /**
  * Expose self closing tags.
@@ -770,7 +923,7 @@ exports.Lexer = Lexer;
 exports.nodes = require('./nodes');
 
 /**
- * Jade runtime mixins.
+ * Jade runtime helpers.
  */
 
 exports.runtime = runtime;
@@ -817,10 +970,24 @@ function parse(str, options){
 }
 
 /**
- * Precompile a string representation of the given jade `str`.
+ * Strip any UTF-8 BOM off of the start of `str`, if it exists.
+ *
+ * @param {String} str
+ * @return {String}
+ * @api private
+ */
+
+function stripBOM(str){
+  return 0xFEFF == str.charCodeAt(0)
+    ? str.substring(1)
+    : str;
+}
+
+/**
+ * Compile a `Function` representation of the given jade `str`.
  *
  * Options:
- * 
+ *
  *   - `compileDebug` when `false` debugging code is stripped from the compiled template
  *   - `client` when `true` the helper functions `escape()` etc will reference `jade.escape()`
  *      for use with the Jade client-side runtime.js
@@ -831,7 +998,7 @@ function parse(str, options){
  * @api public
  */
 
-exports.precompile = function(str, options){
+exports.compile = function(str, options){
   var options = options || {}
     , client = options.client
     , filename = options.filename
@@ -839,52 +1006,31 @@ exports.precompile = function(str, options){
       : 'undefined'
     , fn;
 
+  str = stripBOM(String(str));
+
   if (options.compileDebug !== false) {
     fn = [
         'var __jade = [{ lineno: 1, filename: ' + filename + ' }];'
       , 'try {'
-      , parse(String(str), options)
+      , parse(str, options)
       , '} catch (err) {'
       , '  rethrow(err, __jade[0].filename, __jade[0].lineno);'
       , '}'
     ].join('\n');
   } else {
-    fn = parse(String(str), options);
+    fn = parse(str, options);
   }
 
   if (client) {
-    fn = 'var attrs = jade.attrs, escape = jade.escape, rethrow = jade.rethrow;\n' + fn;
+    fn = 'attrs = attrs || jade.attrs; escape = escape || jade.escape; rethrow = rethrow || jade.rethrow; merge = merge || jade.merge;\n' + fn;
   }
-  
-  return fn;
-}
 
-/**
- * Compile a `Function` representation of the given jade `str`.
- *
- * Options:
- * 
- *   - `compileDebug` when `false` debugging code is stripped from the compiled template
- *   - `client` when `true` the helper functions `escape()` etc will reference `jade.escape()`
- *      for use with the Jade client-side runtime.js
- *
- * @param {String} str
- * @param {Options} options
- * @return {Function}
- * @api public
- */
-
-exports.compile = function(str, options){
-  var options = options || {}
-    , client = options.client,
-    fn;
-  
-  fn = new Function('locals, attrs, escape, rethrow', exports.precompile(str, options));
+  fn = new Function('locals, attrs, escape, rethrow, merge', fn);
 
   if (client) return fn;
 
   return function(locals){
-    return fn(locals, runtime.attrs, runtime.escape, runtime.rethrow);
+    return fn(locals, runtime.attrs, runtime.escape, runtime.rethrow, runtime.merge);
   };
 };
 
@@ -968,6 +1114,8 @@ require.register("lexer.js", function(module, exports, require){
  * MIT Licensed
  */
 
+var utils = require('./utils');
+
 /**
  * Initialize `Lexer` with the given `str`.
  *
@@ -1084,9 +1232,9 @@ Lexer.prototype = {
       , nend = 0
       , pos = 0;
     for (var i = 0, len = str.length; i < len; ++i) {
-      if (start == str[i]) {
+      if (start == str.charAt(i)) {
         ++nstart;
-      } else if (end == str[i]) {
+      } else if (end == str.charAt(i)) {
         if (++nend == nstart) {
           pos = i;
           break;
@@ -1128,6 +1276,19 @@ Lexer.prototype = {
     }
   },
 
+  /**
+   * Blank line.
+   */
+  
+  blank: function() {
+    var captures;
+    if (captures = /^\n *\n/.exec(this.input)) {
+      this.consume(captures[0].length - 1);
+      if (this.pipeless) return this.tok('text', '');
+      return this.next();
+    }
+  },
+
   /**
    * Comment.
    */
@@ -1141,14 +1302,26 @@ Lexer.prototype = {
       return tok;
     }
   },
-  
+
+  /**
+   * Interpolated tag.
+   */
+
+  interpolation: function() {
+    var captures;
+    if (captures = /^#\{(.*?)\}/.exec(this.input)) {
+      this.consume(captures[0].length);
+      return this.tok('interpolation', captures[1]);
+    }
+  },
+
   /**
    * Tag.
    */
   
   tag: function() {
     var captures;
-    if (captures = /^(\w[-:\w]*)/.exec(this.input)) {
+    if (captures = /^(\w[-:\w]*)(\/?)/.exec(this.input)) {
       this.consume(captures[0].length);
       var tok, name = captures[1];
       if (':' == name[name.length - 1]) {
@@ -1159,6 +1332,7 @@ Lexer.prototype = {
       } else {
         tok = this.tok('tag', name);
       }
+      tok.selfClosing = !! captures[2];
       return tok;
     }
   },
@@ -1200,15 +1374,15 @@ Lexer.prototype = {
    */
   
   text: function() {
-    return this.scan(/^(?:\| ?)?([^\n]+)/, 'text');
+    return this.scan(/^(?:\| ?| ?)?([^\n]+)/, 'text');
   },
 
   /**
    * Extends.
    */
   
-  extends: function() {
-    return this.scan(/^extends +([^\n]+)/, 'extends');
+  "extends": function() {
+    return this.scan(/^extends? +([^\n]+)/, 'extends');
   },
 
   /**
@@ -1249,11 +1423,12 @@ Lexer.prototype = {
   
   block: function() {
     var captures;
-    if (captures = /^block +(?:(prepend|append) +)?([^\n]+)/.exec(this.input)) {
+    if (captures = /^block\b *(?:(prepend|append) +)?([^\n]*)/.exec(this.input)) {
       this.consume(captures[0].length);
       var mode = captures[1] || 'replace'
         , name = captures[2]
         , tok = this.tok('block', name);
+
       tok.mode = mode;
       return tok;
     }
@@ -1279,7 +1454,7 @@ Lexer.prototype = {
    * Case.
    */
   
-  case: function() {
+  "case": function() {
     return this.scan(/^case +([^\n]+)/, 'case');
   },
 
@@ -1295,7 +1470,7 @@ Lexer.prototype = {
    * Default.
    */
   
-  default: function() {
+  "default": function() {
     return this.scan(/^default */, 'default');
   },
 
@@ -1313,6 +1488,28 @@ Lexer.prototype = {
     }
   },
 
+  /**
+   * Call mixin.
+   */
+  
+  call: function(){
+    var captures;
+    if (captures = /^\+([-\w]+)/.exec(this.input)) {
+      this.consume(captures[0].length);
+      var tok = this.tok('call', captures[1]);
+      
+      // Check for args (not attributes)
+      if (captures = /^ *\((.*?)\)/.exec(this.input)) {
+        if (!/^ *[-\w]+ *=/.test(captures[1])) {
+          this.consume(captures[0].length);
+          tok.args = captures[1];
+        }
+      }
+      
+      return tok;
+    }
+  },
+
   /**
    * Mixin.
    */
@@ -1353,7 +1550,7 @@ Lexer.prototype = {
    * While.
    */
   
-  while: function() {
+  "while": function() {
     var captures;
     if (captures = /^while +([^\n]+)/.exec(this.input)) {
       this.consume(captures[0].length);
@@ -1398,17 +1595,19 @@ Lexer.prototype = {
    */
   
   attrs: function() {
-    if ('(' == this.input[0]) {
+    if ('(' == this.input.charAt(0)) {
       var index = this.indexOfDelimiters('(', ')')
         , str = this.input.substr(1, index-1)
         , tok = this.tok('attrs')
         , len = str.length
         , colons = this.colons
         , states = ['key']
+        , escapedAttr
         , key = ''
         , val = ''
         , quote
-        , c;
+        , c
+        , p;
 
       function state(){
         return states[states.length - 1];
@@ -1422,6 +1621,7 @@ Lexer.prototype = {
 
       this.consume(index + 1);
       tok.attrs = {};
+      tok.escaped = {};
 
       function parse(c) {
         var real = c;
@@ -1442,7 +1642,9 @@ Lexer.prototype = {
                 val = val.trim();
                 key = key.trim();
                 if ('' == key) return;
-                tok.attrs[key.replace(/^['"]|['"]$/g, '')] = '' == val
+                key = key.replace(/^['"]|['"]$/g, '').replace('!', '');
+                tok.escaped[key] = escapedAttr;
+                tok.attrs[key] = '' == val
                   ? true
                   : interpolate(val);
                 key = val = '';
@@ -1461,6 +1663,7 @@ Lexer.prototype = {
                 val += real;
                 break;
               default:
+                escapedAttr = '!' != p;
                 states.push('val');
             }
             break;
@@ -1521,14 +1724,20 @@ Lexer.prototype = {
                 val += c;
             }
         }
+        p = c;
       }
 
       for (var i = 0; i < len; ++i) {
-        parse(str[i]);
+        parse(str.charAt(i));
       }
 
       parse(',');
 
+      if ('/' == this.input.charAt(0)) {
+        this.consume(1);
+        tok.selfClosing = true;
+      }
+
       return tok;
     }
   },
@@ -1639,22 +1848,25 @@ Lexer.prototype = {
   
   next: function() {
     return this.deferred()
+      || this.blank()
       || this.eos()
       || this.pipelessText()
       || this.yield()
       || this.doctype()
-      || this.case()
+      || this.interpolation()
+      || this["case"]()
       || this.when()
-      || this.default()
-      || this.extends()
+      || this["default"]()
+      || this["extends"]()
       || this.append()
       || this.prepend()
       || this.block()
       || this.include()
       || this.mixin()
+      || this.call()
       || this.conditional()
       || this.each()
-      || this.while()
+      || this["while"]()
       || this.assignment()
       || this.tag()
       || this.filter()
@@ -1671,6 +1883,89 @@ Lexer.prototype = {
 
 }); // module: lexer.js
 
+require.register("nodes/attrs.js", function(module, exports, require){
+
+/*!
+ * Jade - nodes - Attrs
+ * Copyright(c) 2010 TJ Holowaychuk <tj@vision-media.ca>
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var Node = require('./node'),
+    Block = require('./block');
+
+/**
+ * Initialize a `Attrs` node.
+ *
+ * @api public
+ */
+
+var Attrs = module.exports = function Attrs() {
+  this.attrs = [];
+};
+
+/**
+ * Inherit from `Node`.
+ */
+
+Attrs.prototype = new Node;
+Attrs.prototype.constructor = Attrs;
+
+
+/**
+ * Set attribute `name` to `val`, keep in mind these become
+ * part of a raw js object literal, so to quote a value you must
+ * '"quote me"', otherwise or example 'user.name' is literal JavaScript.
+ *
+ * @param {String} name
+ * @param {String} val
+ * @param {Boolean} escaped
+ * @return {Tag} for chaining
+ * @api public
+ */
+
+Attrs.prototype.setAttribute = function(name, val, escaped){
+  this.attrs.push({ name: name, val: val, escaped: escaped });
+  return this;
+};
+
+/**
+ * Remove attribute `name` when present.
+ *
+ * @param {String} name
+ * @api public
+ */
+
+Attrs.prototype.removeAttribute = function(name){
+  for (var i = 0, len = this.attrs.length; i < len; ++i) {
+    if (this.attrs[i] && this.attrs[i].name == name) {
+      delete this.attrs[i];
+    }
+  }
+};
+
+/**
+ * Get attribute value by `name`.
+ *
+ * @param {String} name
+ * @return {String}
+ * @api public
+ */
+
+Attrs.prototype.getAttribute = function(name){
+  for (var i = 0, len = this.attrs.length; i < len; ++i) {
+    if (this.attrs[i] && this.attrs[i].name == name) {
+      return this.attrs[i].val;
+    }
+  }
+};
+
+}); // module: nodes/attrs.js
+
 require.register("nodes/block-comment.js", function(module, exports, require){
 
 /*!
@@ -1743,6 +2038,12 @@ Block.prototype = new Node;
 Block.prototype.constructor = Block;
 
 
+/**
+ * Block flag.
+ */
+
+Block.prototype.isBlock = true;
+
 /**
  * Replace the nodes in `other` with the nodes
  * in `this` block.
@@ -1812,6 +2113,21 @@ Block.prototype.includeBlock = function(){
   return ret;
 };
 
+/**
+ * Return a clone of this block.
+ *
+ * @return {Block}
+ * @api private
+ */
+
+Block.prototype.clone = function(){
+  var clone = new Block;
+  for (var i = 0, len = this.nodes.length; i < len; ++i) {
+    clone.push(this.nodes[i].clone());
+  }
+  return clone;
+};
+
 
 }); // module: nodes/block.js
 
@@ -2045,7 +2361,7 @@ var Filter = module.exports = function Filter(name, block, attrs) {
   this.name = name;
   this.block = block;
   this.attrs = attrs;
-  this.isASTFilter = block instanceof Block;
+  this.isASTFilter = !block.nodes.every(function(node){ return node.isText });
 };
 
 /**
@@ -2104,7 +2420,8 @@ var Node = require('./node');
 
 var Literal = module.exports = function Literal(str) {
   this.str = str
-    .replace(/\n/g, "\\n")
+    .replace(/\\/g, "\\\\")
+    .replace(/\n|\r\n/g, "\\n")
     .replace(/'/g, "\\'");
 };
 
@@ -2130,7 +2447,7 @@ require.register("nodes/mixin.js", function(module, exports, require){
  * Module dependencies.
  */
 
-var Node = require('./node');
+var Attrs = require('./attrs');
 
 /**
  * Initialize a new `Mixin` with `name` and `block`.
@@ -2141,17 +2458,19 @@ var Node = require('./node');
  * @api public
  */
 
-var Mixin = module.exports = function Mixin(name, args, block){
+var Mixin = module.exports = function Mixin(name, args, block, call){
   this.name = name;
   this.args = args;
   this.block = block;
+  this.attrs = [];
+  this.call = call;
 };
 
 /**
- * Inherit from `Node`.
+ * Inherit from `Attrs`.
  */
 
-Mixin.prototype = new Node;
+Mixin.prototype = new Attrs;
 Mixin.prototype.constructor = Mixin;
 
 
@@ -2173,6 +2492,18 @@ require.register("nodes/node.js", function(module, exports, require){
  */
 
 var Node = module.exports = function Node(){};
+
+/**
+ * Clone this node (return itself)
+ *
+ * @return {Node}
+ * @api private
+ */
+
+Node.prototype.clone = function(){
+  return this;
+};
+
 }); // module: nodes/node.js
 
 require.register("nodes/tag.js", function(module, exports, require){
@@ -2187,8 +2518,9 @@ require.register("nodes/tag.js", function(module, exports, require){
  * Module dependencies.
  */
 
-var Node = require('./node'),
-    Block = require('./block');
+var Attrs = require('./attrs'),
+    Block = require('./block'),
+    inlineTags = require('../inline-tags');
 
 /**
  * Initialize a `Tag` node with the given tag `name` and optional `block`.
@@ -2205,60 +2537,73 @@ var Tag = module.exports = function Tag(name, block) {
 };
 
 /**
- * Inherit from `Node`.
+ * Inherit from `Attrs`.
  */
 
-Tag.prototype = new Node;
+Tag.prototype = new Attrs;
 Tag.prototype.constructor = Tag;
 
 
 /**
- * Set attribute `name` to `val`, keep in mind these become
- * part of a raw js object literal, so to quote a value you must
- * '"quote me"', otherwise or example 'user.name' is literal JavaScript.
+ * Clone this tag.
  *
- * @param {String} name
- * @param {String} val
- * @return {Tag} for chaining
- * @api public
+ * @return {Tag}
+ * @api private
  */
 
-Tag.prototype.setAttribute = function(name, val){
-  this.attrs.push({ name: name, val: val });
-  return this;
+Tag.prototype.clone = function(){
+  var clone = new Tag(this.name, this.block.clone());
+  clone.line = this.line;
+  clone.attrs = this.attrs;
+  clone.textOnly = this.textOnly;
+  return clone;
 };
 
 /**
- * Remove attribute `name` when present.
+ * Check if this tag is an inline tag.
  *
- * @param {String} name
- * @api public
+ * @return {Boolean}
+ * @api private
  */
 
-Tag.prototype.removeAttribute = function(name){
-  for (var i = 0, len = this.attrs.length; i < len; ++i) {
-    if (this.attrs[i] && this.attrs[i].name == name) {
-      delete this.attrs[i];
-    }
-  }
+Tag.prototype.isInline = function(){
+  return ~inlineTags.indexOf(this.name);
 };
 
 /**
- * Get attribute value by `name`.
+ * Check if this tag's contents can be inlined.  Used for pretty printing.
  *
- * @param {String} name
- * @return {String}
- * @api public
+ * @return {Boolean}
+ * @api private
  */
 
-Tag.prototype.getAttribute = function(name){
-  for (var i = 0, len = this.attrs.length; i < len; ++i) {
-    if (this.attrs[i] && this.attrs[i].name == name) {
-      return this.attrs[i].val;
+Tag.prototype.canInline = function(){
+  var nodes = this.block.nodes;
+
+  function isInline(node){
+    // Recurse if the node is a block
+    if (node.isBlock) return node.nodes.every(isInline);
+    return node.isText || (node.isInline && node.isInline());
+  }
+  
+  // Empty tag
+  if (!nodes.length) return true;
+  
+  // Text-only or inline-only tag
+  if (1 == nodes.length) return isInline(nodes[0]);
+  
+  // Multi-line inline-only tag
+  if (this.block.nodes.every(isInline)) {
+    for (var i = 1, len = nodes.length; i < len; ++i) {
+      if (nodes[i-1].isText && nodes[i].isText)
+        return false;
     }
+    return true;
   }
+  
+  // Mixed tag
+  return false;
 };
-
 }); // module: nodes/tag.js
 
 require.register("nodes/text.js", function(module, exports, require){
@@ -2283,8 +2628,8 @@ var Node = require('./node');
  */
 
 var Text = module.exports = function Text(line) {
-  this.nodes = [];
-  if ('string' == typeof line) this.push(line);
+  this.val = '';
+  if ('string' == typeof line) this.val = line;
 };
 
 /**
@@ -2296,17 +2641,10 @@ Text.prototype.constructor = Text;
 
 
 /**
- * Push the given `node.`
- *
- * @param {Node} node
- * @return {Number}
- * @api public
+ * Flag as text.
  */
 
-Text.prototype.push = function(node){
-  return this.nodes.push(node);
-};
-
+Text.prototype.isText = true;
 }); // module: nodes/text.js
 
 require.register("parser.js", function(module, exports, require){
@@ -2338,6 +2676,7 @@ var Parser = exports = module.exports = function Parser(str, filename, options){
   this.lexer = new Lexer(str, options);
   this.filename = filename;
   this.blocks = {};
+  this.mixins = {};
   this.options = options;
   this.contexts = [this];
 };
@@ -2446,6 +2785,9 @@ Parser.prototype = {
       this.context(parser);
       var ast = parser.parse();
       this.context();
+      // hoist mixins
+      for (var name in this.mixins)
+        ast.unshift(this.mixins[name]);
       return ast;
     }
 
@@ -2493,6 +2835,7 @@ Parser.prototype = {
    * | yield
    * | id
    * | class
+   * | interpolation
    */
   
   parseExpr: function(){
@@ -2525,6 +2868,10 @@ Parser.prototype = {
         return this.parseEach();
       case 'code':
         return this.parseCode();
+      case 'call':
+        return this.parseCall();
+      case 'interpolation':
+        return this.parseInterpolation();
       case 'yield':
         this.advance();
         var block = new nodes.Block;
@@ -2688,6 +3035,10 @@ Parser.prototype = {
       , node = new nodes.Each(tok.code, tok.val, tok.key);
     node.line = this.line();
     node.block = this.block();
+    if (this.peek().type == 'code' && this.peek().val == 'else') {
+      this.advance();
+      node.alternative = this.block();
+    }
     return node;
   },
 
@@ -2784,6 +3135,8 @@ Parser.prototype = {
     var path = join(dir, path)
       , str = fs.readFileSync(path, 'utf8')
      , parser = new Parser(str, path, this.options);
+    parser.blocks = this.blocks;
+    parser.mixins = this.mixins;
 
     this.context(parser);
     var ast = parser.parse();
@@ -2797,6 +3150,21 @@ Parser.prototype = {
     return ast;
   },
 
+  /**
+   * call ident block
+   */
+
+  parseCall: function(){
+    var tok = this.expect('call')
+      , name = tok.val
+      , args = tok.args
+      , mixin = new nodes.Mixin(name, args, new nodes.Block, true);
+
+    this.tag(mixin);
+    if (mixin.block.isEmpty()) mixin.block = null;
+    return mixin;
+  },
+
   /**
    * mixin block
    */
@@ -2804,11 +3172,18 @@ Parser.prototype = {
   parseMixin: function(){
     var tok = this.expect('mixin')
       , name = tok.val
-      , args = tok.args;
-    var block = 'indent' == this.peek().type
-      ? this.block()
-      : null;
-    return new nodes.Mixin(name, args, block);
+      , args = tok.args
+      , mixin;
+
+    // definition
+    if ('indent' == this.peek().type) {
+      mixin = new nodes.Mixin(name, args, this.block(), false);
+      this.mixins[name] = mixin;
+      return mixin;
+    // call
+    } else {
+      return new nodes.Mixin(name, args, null, true);
+    }
   },
 
   /**
@@ -2816,32 +3191,31 @@ Parser.prototype = {
    */
 
   parseTextBlock: function(){
-    var text = new nodes.Text;
-    text.line = this.line();
+    var block = new nodes.Block;
+    block.line = this.line();
     var spaces = this.expect('indent').val;
     if (null == this._spaces) this._spaces = spaces;
     var indent = Array(spaces - this._spaces + 1).join(' ');
     while ('outdent' != this.peek().type) {
       switch (this.peek().type) {
         case 'newline':
-          text.push('\\n');
           this.advance();
           break;
         case 'indent':
-          text.push('\\n');
           this.parseTextBlock().nodes.forEach(function(node){
-            text.push(node);
+            block.push(node);
           });
-          text.push('\\n');
           break;
         default:
-          text.push(indent + this.advance().val);
+          var text = new nodes.Text(indent + this.advance().val);
+          text.line = this.line();
+          block.push(text);
       }
     }
 
     if (spaces == this._spaces) this._spaces = null;
     this.expect('outdent');
-    return text;
+    return block;
   },
 
   /**
@@ -2863,6 +3237,17 @@ Parser.prototype = {
     return block;
   },
 
+  /**
+   * interpolation (attrs | class | id)* (text | code | ':')? newline* block?
+   */
+  
+  parseInterpolation: function(){
+    var tok = this.advance();
+    var tag = new nodes.Tag(tok.val);
+    tag.buffer = true;
+    return this.tag(tag);
+  },
+
   /**
    * tag (attrs | class | id)* (text | code | ':')? newline* block?
    */
@@ -2877,9 +3262,20 @@ Parser.prototype = {
       }
     }
 
-    var name = this.advance().val
-      , tag = new nodes.Tag(name)
-      , dot;
+    var tok = this.advance()
+      , tag = new nodes.Tag(tok.val);
+
+    tag.selfClosing = tok.selfClosing;
+
+    return this.tag(tag);
+  },
+
+  /**
+   * Parse tag.
+   */
+
+  tag: function(tag){
+    var dot;
 
     tag.line = this.line();
 
@@ -2893,12 +3289,17 @@ Parser.prototype = {
             tag.setAttribute(tok.type, "'" + tok.val + "'");
             continue;
           case 'attrs':
-            var obj = this.advance().attrs
+            var tok = this.advance()
+              , obj = tok.attrs
+              , escaped = tok.escaped
               , names = Object.keys(obj);
+
+            if (tok.selfClosing) tag.selfClosing = true;
+
             for (var i = 0, len = names.length; i < len; ++i) {
               var name = names[i]
                 , val = obj[name];
-              tag.setAttribute(name, val);
+              tag.setAttribute(name, val, escaped[name]);
             }
             continue;
           default:
@@ -2915,7 +3316,7 @@ Parser.prototype = {
     // (text | code | ':')?
     switch (this.peek().type) {
       case 'text':
-        tag.text = this.parseText();
+        tag.block.push(this.parseText());
         break;
       case 'code':
         tag.code = this.parseCode();
@@ -2923,7 +3324,7 @@ Parser.prototype = {
       case ':':
         this.advance();
         tag.block = new nodes.Block;
-        tag.block.push(this.parseTag());
+        tag.block.push(this.parseExpr());
         break;
     }
 
@@ -2995,41 +3396,97 @@ if (!Object.keys) {
       }
     }
     return arr;
-  } 
+  }
+}
+
+/**
+ * Merge two attribute objects giving precedence
+ * to values in object `b`. Classes are special-cased
+ * allowing for arrays and merging/joining appropriately
+ * resulting in a string.
+ *
+ * @param {Object} a
+ * @param {Object} b
+ * @return {Object} a
+ * @api private
+ */
+
+exports.merge = function merge(a, b) {
+  var ac = a['class'];
+  var bc = b['class'];
+
+  if (ac || bc) {
+    ac = ac || [];
+    bc = bc || [];
+    if (!Array.isArray(ac)) ac = [ac];
+    if (!Array.isArray(bc)) bc = [bc];
+    ac = ac.filter(nulls);
+    bc = bc.filter(nulls);
+    a['class'] = ac.concat(bc).join(' ');
+  }
+
+  for (var key in b) {
+    if (key != 'class') {
+      a[key] = b[key];
+    }
+  }
+
+  return a;
+};
+
+/**
+ * Filter null `val`s.
+ *
+ * @param {Mixed} val
+ * @return {Mixed}
+ * @api private
+ */
+
+function nulls(val) {
+  return val != null;
 }
 
 /**
  * Render the given attributes object.
  *
  * @param {Object} obj
+ * @param {Object} escaped
  * @return {String}
  * @api private
  */
 
-exports.attrs = function attrs(obj){
+exports.attrs = function attrs(obj, escaped){
   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 (0 == key.indexOf('data') && 'string' != typeof val) {
+        buf.push(key + "='" + JSON.stringify(val) + "'");
       } else if ('class' == key && Array.isArray(val)) {
         buf.push(key + '="' + exports.escape(val.join(' ')) + '"');
-      } else {
+      } else if (escaped && escaped[key]) {
         buf.push(key + '="' + exports.escape(val) + '"');
+      } else {
+        buf.push(key + '="' + val + '"');
       }
     }
   }
+
   return buf.join(' ');
 };
 
@@ -3043,7 +3500,7 @@ exports.attrs = function attrs(obj){
 
 exports.escape = function escape(html){
   return String(html)
-    .replace(/&(?!\w+;)/g, '&amp;')
+    .replace(/&(?!(\w+|\#\d+);)/g, '&amp;')
     .replace(/</g, '&lt;')
     .replace(/>/g, '&gt;')
     .replace(/"/g, '&quot;');
@@ -3062,30 +3519,25 @@ exports.escape = function escape(html){
 exports.rethrow = function rethrow(err, filename, lineno){
   if (!filename) throw err;
 
-  // If we can't catch the context we still output line and file
-  try {
-    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') + '\n\n';
-  } catch(failure) {
-    var context = '';
-  }
+  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 + err.message;
+  err.message = (filename || 'Jade') + ':' + lineno
+    + '\n' + context + '\n\n' + err.message;
   throw err;
 };
 
@@ -3104,6 +3556,7 @@ module.exports = [
   , 'img'
   , 'link'
   , 'input'
+  , 'source'
   , 'area'
   , 'base'
   , 'col'