haml-edge 2.3.155 → 2.3.158

data/EDGE_GEM_VERSION

@@ -1 +1 @@
-2.3.155
+2.3.158

data/Rakefile

@@ -213,7 +213,6 @@ task :release_edge do
     sh %{rake package}
     sh %{git checkout VERSION}
 
-    sh %{rubyforge login}
     sh %{rubyforge add_release haml haml-edge "Bleeding Edge (v#{edge_version})" pkg/haml-edge-#{edge_version}.gem}
     sh %{gem push pkg/haml-edge-#{edge_version}.gem}
   end

data/VERSION

@@ -1 +1 @@
-2.3.155
+2.3.158

data/lib/haml/engine.rb

@@ -99,7 +99,7 @@ module Haml
         @options[:encoding] = @options[:encoding].name
       end
 
-      check_encoding(template) {|msg, line| raise Haml::Error.new(msg, line)}
+      template = check_encoding(template) {|msg, line| raise Haml::Error.new(msg, line)}
 
       # :eod is a special end-of-document marker
       @template = (template.rstrip).split(/\r\n|\r|\n/) + [:eod, :eod]

data/lib/haml/html.rb

@@ -127,7 +127,7 @@ module Haml
           template = template.read
         end
 
-        Haml::Util.check_encoding(template) {|msg, line| raise Haml::Error.new(msg, line)}
+        template = Haml::Util.check_encoding(template) {|msg, line| raise Haml::Error.new(msg, line)}
 
         if @options[:erb]
           require 'haml/html/erb'

data/lib/haml/util.rb

@@ -237,7 +237,8 @@ module Haml
       Haml::Util::RUBY_VERSION[0] == 1 && Haml::Util::RUBY_VERSION[1] < 9
     end
 
-    # Checks that the encoding of a string is valid in Ruby 1.9.
+    # Checks that the encoding of a string is valid in Ruby 1.9
+    # and cleans up potential encoding gotchas like the UTF-8 BOM.
     # If it's not, yields an error string describing the invalid character
     # and the line on which it occurrs.
     #
@@ -245,9 +246,19 @@ module Haml
     # @yield [msg] A block in which an encoding error can be raised.
     #   Only yields if there is an encoding error
     # @yieldparam msg [String] The error message to be raised
+    # @return [String] `str`, potentially with encoding gotchas like BOMs removed
     def check_encoding(str)
-      return if ruby1_8?
-      return if str.valid_encoding?
+      if ruby1_8?
+        return str.gsub(/\A\xEF\xBB\xBF/, '') # Get rid of the UTF-8 BOM
+      elsif str.valid_encoding?
+        # Get rid of the Unicode BOM if possible
+        if str.encoding.name =~ /^UTF-(8|16|32)(BE|LE)?$/
+          return str.gsub(Regexp.new("\\A\uFEFF".encode(str.encoding.name)), '')
+        else
+          return str
+        end
+      end
+
       encoding = str.encoding
       newlines = Regexp.new("\r\n|\r|\n".encode(encoding).force_encoding("binary"))
       str.force_encoding("binary").split(newlines).each_with_index do |line, i|
@@ -259,6 +270,7 @@ Invalid #{encoding.name} character #{e.error_char.dump}
 MSG
         end
       end
+      return str
     end
 
     # Checks to see if a class has a given method.

data/lib/sass/css.rb

@@ -76,7 +76,7 @@ module Sass
       @options = options.dup
       # Backwards compatibility
       @options[:old] = true if @options[:alternate] == false
-      @template = StringScanner.new(template)
+      @template_str = template
     end
 
     # Converts the CSS template into Sass code.
@@ -84,10 +84,10 @@ module Sass
     # @return [String] The resulting Sass code
     # @raise [Sass::SyntaxError] if there's an error parsing the CSS template
     def render
-      Haml::Util.check_encoding(@template.string) do |msg, line|
-        raise Sass::SyntaxError.new(msg, :line => line)
-      end
-
+      @template = StringScanner.new(
+        Haml::Util.check_encoding(@template_str) do |msg, line|
+          raise Sass::SyntaxError.new(msg, :line => line)
+        end)
       build_tree.to_sass(0, @options).strip + "\n"
     rescue Sass::SyntaxError => err
       err.modify_backtrace(:filename => @options[:filename] || '(css)', :line => @line)

data/lib/sass/engine.rb

@@ -172,7 +172,7 @@ module Sass
     # @return [Sass::Tree::Node] The root of the parse tree.
     # @raise [Sass::SyntaxError] if there's an error in the document
     def to_tree
-      check_encoding(@template) {|msg, line| raise Sass::SyntaxError.new(msg, :line => line)}
+      @template = check_encoding(@template) {|msg, line| raise Sass::SyntaxError.new(msg, :line => line)}
 
       root = Tree::RootNode.new(@template)
       append_children(root, tree(tabulate(@template)).first, true)

data/test/haml/engine_test.rb

@@ -1250,6 +1250,17 @@ SASS
 
   # Encodings
 
+  def test_utf_8_bom
+    assert_equal <<CSS, render(<<SCSS)
+<div class='foo'>
+  <p>baz</p>
+</div>
+CSS
+\xEF\xBB\xBF.foo
+  %p baz
+SCSS
+  end
+
   unless Haml::Util.ruby1_8?
     def test_default_encoding
       assert_equal(Encoding.find("utf-8"), render(<<HAML.encode("us-ascii")).encoding)

data/test/haml/spec/README.md

@@ -0,0 +1,97 @@
+# Haml Spec #
+
+Haml Spec provides a basic suite of tests for Haml interpreters.
+
+It is intented for developers who are creating or maintaining an implementation
+of the [Haml](http://haml-lang.com) markup language.
+
+At the moment, there are test runners for the [original Haml](http://github.com/nex3/haml)
+in Ruby, and for [Lua Haml](http://github.com/norman/lua-haml). Support for
+other versions of Haml will be added if their developers/maintainers
+are interested in using it.
+
+## The Tests ##
+
+The tests are kept in JSON format for portability across languages.  Each test
+is a JSON object with expected input, output, local variables and configuration
+parameters (see below).  The test suite only provides tests for features which
+are portable, therefore no tests for script are provided, nor for external
+filters such as :markdown or :textile.
+
+The one major exception to this are the tests for interpolation, which you may
+need to modify with a regular expression to run under PHP or Perl, which
+require a symbol before variable names. These tests are included despite being
+less than 100% portable because interpolation is an important part of Haml and
+can be tricky to implement.
+
+## Running the Tests ##
+
+### Ruby ###
+
+In order to make it as easy as possible for non-Ruby programmers to run the
+Ruby Haml tests, the Ruby test runner uses test/unit, rather than something
+fancier like Rspec.  To run them you probably only need to install `haml`, and
+possibly `ruby` if your platform doesn't come with it by default. If you're
+using Ruby 1.8.x, you'll also need to install `json`:
+
+    sudo gem install haml
+    # for Ruby 1.8.x; check using "ruby --version" if unsure
+    sudo gem install json
+
+Then, running the Ruby test suite is easy:
+
+    ruby ruby_haml_test.rb
+
+### Lua ###
+
+The Lua test depends on [Telescope](http://telescope.luaforge.net/),
+[jason4lua](http://json.luaforge.net/), and
+[Lua Haml](http://github.com/norman/lua-haml). Install and
+run `tsc lua_haml_spec.lua`.
+
+## Contributing ##
+
+### Getting it ###
+
+You can access the [Git repository](http://github.com/norman/haml-spec) at:
+
+    git://github.com/norman/haml-spec.git
+
+Patches are *very* welcome, as are test runners for your Haml implementation.
+
+As long as any test you add run against Ruby Haml and are not redundant, I'll
+be very happy to add them.
+
+### Test JSON format ###
+
+    "test name" : {
+      "haml" : "haml input",
+      "html" : "expected html output",
+      "result" : "expected test result",
+      "locals" : "local vars",
+      "config" : "config params"
+    }
+
+* test name: This should be a *very* brief description of what's being tested. It can
+  be used by the test runners to name test methods, or to exclude certain tests from being
+  run.
+* haml: The Haml code to be evaluated. Always required.
+* html: The HTML output that should be generated. Required unless "result" is "error".
+* result: Can be "pass" or "error". If it's absent, then "pass" is assumed. If it's "error",
+  then the goal of the test is to make sure that malformed Haml code generates an error.
+* locals: An object containing local variables needed for the test.
+* config: An object containing configuration parameters used to run the test.
+  The configuration parameters should be usable directly by Ruby's Haml with no
+  modification.  If your implementation uses config parameters with different
+  names, you may need to process them to make them match your implementation.
+  If your implementation has options that do not exist in Ruby's Haml, then you
+  should add tests for this in your implementation's test rather than here.
+
+## License ##
+
+  This project is released under the [WTFPL](http://sam.zoy.org/wtfpl/) in order
+  to be as usable as possible in any project, commercial or free.
+
+## Author ##
+
+  [Norman Clarke](mailto:norman@njclarke.com)

data/test/haml/spec/lua_haml_spec.lua

@@ -0,0 +1,30 @@
+require 'luarocks.require'
+require 'json'
+require 'telescope'
+require 'haml'
+
+local function get_tests(filename)
+  local self = debug.getinfo(1).short_src
+  if self:match("/") then return "./" .. self:gsub("[^/]*%.lua$", "/" .. filename)
+  elseif self:match("\\") then return self:gsub("[^\\]*%.lua$", "\\" .. filename)
+  else return filename
+  end
+end
+
+local fh = assert(io.open(get_tests("tests.json")))
+local input = fh:read '*a'
+fh:close()
+
+local contexts = json.decode(input)
+
+describe("LuaHaml", function()
+   for context, expectations in pairs(contexts) do
+     describe("When handling " .. context, function()
+      for name, exp in pairs(expectations) do
+        it(string.format("should correctly render %s", name), function()
+            assert_equal(haml.render(exp.haml, exp.config or {}, exp.locals or {}), exp.html)
+        end)
+      end
+     end)
+   end
+end)

data/test/haml/spec/ruby_haml_test.rb

@@ -0,0 +1,19 @@
+require "test/unit"
+require "json"
+require "haml"
+
+class HamlTest < Test::Unit::TestCase
+  contexts = JSON.parse(File.read(File.dirname(__FILE__) + "/tests.json"))
+  contexts.each do |context|
+    context[1].each do |name, test|
+      class_eval(<<-EOTEST)
+        def test_#{name.gsub(/\s+|[^a-zA-Z0-9_]/, "_")}
+          locals = Hash[*(#{test}["locals"] || {}).collect {|k, v| [k.to_sym, v] }.flatten]
+          options = Hash[*(#{test}["config"] || {}).collect {|k, v| [k.to_sym, v.to_sym] }.flatten]
+          engine = Haml::Engine.new(#{test}["haml"], options)
+          assert_equal(engine.render(Object.new, locals).chomp, #{test}["html"])
+        end
+      EOTEST
+    end
+  end
+end

data/test/haml/spec/tests.json

@@ -0,0 +1,534 @@
+{
+  "headers" : {
+
+    "an XHTML XML prolog" : {
+      "haml" : "!!! XML",
+      "html" : "<?xml version='1.0' encoding='utf-8' ?>"
+    },
+
+    "an XHTML default (transitional) doctype" : {
+      "haml" : "!!!",
+      "html" : "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">"
+    },
+
+    "an XHTML 1.1 doctype" : {
+      "haml" : "!!! 1.1",
+      "html" : "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.1//EN\" \"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd\">"
+    },
+
+    "an XHTML 1.2 mobile doctype" : {
+      "haml" : "!!! mobile",
+      "html" : "<!DOCTYPE html PUBLIC \"-//WAPFORUM//DTD XHTML Mobile 1.2//EN\" \"http://www.openmobilealliance.org/tech/DTD/xhtml-mobile12.dtd\">"
+    },
+
+    "an XHTML 1.1 basic doctype" : {
+      "haml" : "!!! basic",
+      "html" : "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML Basic 1.1//EN\" \"http://www.w3.org/TR/xhtml-basic/xhtml-basic11.dtd\">"
+    },
+
+    "an XHTML 1.0 frameset doctype" : {
+      "haml" : "!!! frameset",
+      "html" : "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Frameset//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd\">"
+    },
+
+    "an HTML 5 doctype with XHTML syntax" : {
+      "haml" : "!!! 5",
+      "html" : "<!DOCTYPE html>"
+    },
+
+    "an HTML 5 XML prolog (silent)" : {
+      "haml" : "!!! XML",
+      "html" : "",
+      "config" : {
+        "format" : "html5"
+      }
+    },
+
+    "an HTML 5 doctype" : {
+      "haml" : "!!!",
+      "html" : "<!DOCTYPE html>",
+      "config" : {
+        "format" : "html5"
+      }
+    },
+
+    "an HTML 4 XML prolog (silent)" : {
+      "haml" : "!!! XML",
+      "html" : "",
+      "config" : {
+        "format" : "html4"
+      }
+    },
+
+    "an HTML 4 default (transitional) doctype" : {
+      "haml" : "!!!",
+      "html" : "<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"http://www.w3.org/TR/html4/loose.dtd\">",
+      "config" : {
+        "format" : "html4"
+      }
+    },
+
+    "an HTML 4 frameset doctype" : {
+      "haml" : "!!! frameset",
+      "html" : "<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01 Frameset//EN\" \"http://www.w3.org/TR/html4/frameset.dtd\">",
+      "config" : {
+        "format" : "html4"
+      }
+    },
+
+    "an HTML 4 strict doctype" : {
+      "haml" : "!!! strict",
+      "html" : "<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01//EN\" \"http://www.w3.org/TR/html4/strict.dtd\">",
+      "config" : {
+        "format" : "html4"
+      }
+    }
+
+  },
+
+  "basic Haml tags and CSS": {
+
+    "a simple Haml tag" : {
+      "haml" : "%p",
+      "html" : "<p></p>"
+    },
+
+    "a self-closing tag (XHTML)" : {
+      "haml" : "%meta",
+      "html" : "<meta />"
+    },
+
+    "a self-closing tag (HTML4)" : {
+      "haml" : "%meta",
+      "html" : "<meta>",
+      "config" : {
+        "format" : "html4"
+      }
+    },
+
+    "a self-closing tag (HTML5)" : {
+      "haml" : "%meta",
+      "html" : "<meta>",
+      "config" : {
+        "format" : "html5"
+      }
+    },
+
+    "a tag with a CSS class" : {
+      "haml" : "%p.class1",
+      "html" : "<p class='class1'></p>"
+    },
+
+    "a tag with multiple CSS classes" : {
+      "haml" : "%p.class1.class2",
+      "html" : "<p class='class1 class2'></p>"
+    },
+
+    "a tag with a CSS id" : {
+      "haml" : "%p#id1",
+      "html" : "<p id='id1'></p>"
+    },
+
+    "a tag with multiple CSS id's" : {
+      "haml" : "%p#id1#id2",
+      "html" : "<p id='id2'></p>"
+    },
+
+    "a tag with a class followed by an id" : {
+      "haml" : "%p.class1#id1",
+      "html" : "<p class='class1' id='id1'></p>"
+    },
+
+    "a tag with an id followed by a class" : {
+      "haml" : "%p#id1.class1",
+      "html" : "<p class='class1' id='id1'></p>"
+    },
+
+    "an implicit div with a CSS id" : {
+      "haml" : "#id1",
+      "html" : "<div id='id1'></div>"
+    },
+
+    "an implicit div with a CSS class" : {
+      "haml" : ".class1",
+      "html" : "<div class='class1'></div>"
+    },
+
+    "multiple simple Haml tags" : {
+      "haml" : "%div\n  %div\n    %p",
+      "html" : "<div>\n  <div>\n    <p></p>\n  </div>\n</div>"
+	}
+  },
+
+  "tags with unusual HTML characters" : {
+
+    "a tag with colons" : {
+      "haml" : "%ns:tag",
+      "html" : "<ns:tag></ns:tag>"
+    },
+
+    "a tag with underscores" : {
+      "haml" : "%snake_case",
+      "html" : "<snake_case></snake_case>"
+    },
+
+    "a tag with dashes" : {
+      "haml" : "%dashed-tag",
+      "html" : "<dashed-tag></dashed-tag>"
+    },
+
+    "a tag with camelCase" : {
+      "haml" : "%camelCase",
+      "html" : "<camelCase></camelCase>"
+    },
+
+    "a tag with PascalCase" : {
+      "haml" : "%PascalCase",
+      "html" : "<PascalCase></PascalCase>"
+    }
+  },
+
+  "tags with unusual CSS identifiers" : {
+
+    "an all-numeric class" : {
+      "haml" : ".123",
+      "html" : "<div class='123'></div>"
+    },
+
+    "a class with underscores" : {
+      "haml" : ".__",
+      "html" : "<div class='__'></div>"
+    },
+
+    "a class with dashes" : {
+      "haml" : ".--",
+      "html" : "<div class='--'></div>"
+    }
+
+  },
+
+  "tags with inline content" : {
+
+    "a simple tag" : {
+      "haml" : "%p hello",
+      "html" : "<p>hello</p>"
+    },
+
+    "a tag with CSS" : {
+      "haml" : "%p.class1 hello",
+      "html" : "<p class='class1'>hello</p>"
+    },
+
+    "multiple simple tags" : {
+      "haml" : "%div\n  %div\n    %p text",
+      "html" : "<div>\n  <div>\n    <p>text</p>\n  </div>\n</div>"
+    }
+  },
+
+  "tags with nested content" : {
+
+    "a simple tag" : {
+      "haml" : "%p\n  hello",
+      "html" : "<p>\n  hello\n</p>"
+    },
+
+    "a tag with CSS" : {
+      "haml" : "%p.class1\n  hello",
+      "html" : "<p class='class1'>\n  hello\n</p>"
+    },
+
+    "multiple simple tags" : {
+      "haml" : "%div\n  %div\n    %p\n      text",
+      "html" : "<div>\n  <div>\n    <p>\n      text\n    </p>\n  </div>\n</div>"
+    }
+
+  },
+
+  "tags with HTML-style attributes": {
+
+    "one attribute" : {
+      "haml" : "%p(a='b')",
+      "html" : "<p a='b'></p>"
+    },
+
+    "multiple attributes" : {
+      "haml" : "%p(a='b' c='d')",
+      "html" : "<p a='b' c='d'></p>"
+    },
+
+    "attributes separated with newlines" : {
+      "haml" : "%p(a='b'\n  c='d')",
+      "html" : "<p a='b' c='d'></p>"
+    },
+
+    "an interpolated attribute" : {
+      "haml" : "%p(a=\"#{var}\")",
+      "html" : "<p a='value'></p>",
+      "locals" : {
+        "var" : "value"
+      }
+    },
+
+    "'class' as an attribute" : {
+      "haml" : "%p(class='class1')",
+      "html" : "<p class='class1'></p>"
+    },
+
+    "a tag with a CSS class and 'class' as an attribute" : {
+      "haml" : "%p.class2(class='class1')",
+      "html" : "<p class='class1 class2'></p>"
+    },
+
+    "a tag with 'id' as an attribute" : {
+      "haml" : "%p(id='1')",
+      "html" : "<p id='1'></p>"
+    },
+
+    "a tag with a CSS id and 'id' as an attribute" : {
+      "haml" : "%p#id(id='1')",
+      "html" : "<p id='id_1'></p>"
+    },
+
+    "a tag with a variable attribute" : {
+      "haml" : "%p(class=var)",
+      "html" : "<p class='hello'></p>",
+      "locals" : {
+        "var" : "hello"
+      }
+    },
+
+    "a tag with a CSS class and 'class' as a variable attribute" : {
+      "haml" : ".hello(class=var)",
+      "html" : "<div class='hello world'></div>",
+      "locals" : {
+        "var" : "world"
+      }
+    },
+
+    "a tag multiple CSS classes (sorted correctly)" : {
+      "haml" : ".z(class=var)",
+      "html" : "<div class='a z'></div>",
+      "locals" : {
+        "var" : "a"
+      }
+    }
+
+  },
+
+  "tags with Ruby-style attributes": {
+
+    "one attribute" : {
+      "haml" : "%p{:a => 'b'}",
+      "html" : "<p a='b'></p>"
+    },
+
+    "attributes hash with whitespace" : {
+      "haml" : "%p{  :a  =>  'b'  }",
+      "html" : "<p a='b'></p>"
+    },
+
+    "an interpolated attribute" : {
+      "haml" : "%p{:a =>\"#{var}\"}",
+      "html" : "<p a='value'></p>",
+      "locals" : {
+        "var" : "value"
+      }
+    },
+
+    "multiple attributes" : {
+      "haml" : "%p{ :a => 'b', 'c' => 'd' }",
+      "html" : "<p a='b' c='d'></p>"
+    },
+
+    "attributes separated with newlines" : {
+      "haml" : "%p{ :a => 'b',\n  'c' => 'd' }",
+      "html" : "<p a='b' c='d'></p>"
+    },
+
+    "'class' as an attribute" : {
+      "haml" : "%p{:class => 'class1'}",
+      "html" : "<p class='class1'></p>"
+    },
+
+    "a tag with a CSS class and 'class' as an attribute" : {
+      "haml" : "%p.class2{:class => 'class1'}",
+      "html" : "<p class='class1 class2'></p>"
+    },
+
+    "a tag with 'id' as an attribute" : {
+      "haml" : "%p{:id => '1'}",
+      "html" : "<p id='1'></p>"
+    },
+
+    "a tag with a CSS id and 'id' as an attribute" : {
+      "haml" : "%p#id{:id => '1'}",
+      "html" : "<p id='id_1'></p>"
+    },
+
+    "a tag with a CSS id and a numeric 'id' as an attribute" : {
+      "haml" : "%p#id{:id => 1}",
+      "html" : "<p id='id_1'></p>"
+    },
+
+    "a tag with a variable attribute" : {
+      "haml" : "%p{:class => var}",
+      "html" : "<p class='hello'></p>",
+      "locals" : {
+        "var" : "hello"
+      }
+    },
+
+    "a tag with a CSS class and 'class' as a variable attribute" : {
+      "haml" : ".hello{:class => var}",
+      "html" : "<div class='hello world'></div>",
+      "locals" : {
+        "var" : "world"
+      }
+    },
+
+    "a tag multiple CSS classes (sorted correctly)" : {
+      "haml" : ".z{:class => var}",
+      "html" : "<div class='a z'></div>",
+      "locals" : {
+        "var" : "a"
+      }
+    }
+
+  },
+
+  "silent comments" : {
+
+    "an inline comment" : {
+      "haml" : "-# hello",
+      "html" : ""
+    },
+
+    "a nested comment" : {
+      "haml" : "-#\n  hello",
+      "html" : ""
+    }
+
+  },
+
+  "markup comments" : {
+
+    "an inline comment" : {
+      "haml" : "/ comment",
+      "html" : "<!-- comment -->"
+    },
+
+    "a nested comment" : {
+      "haml" : "/\n  comment\n  comment2",
+      "html" : "<!--\n  comment\n  comment2\n-->"
+    }
+  },
+
+  "conditional comments": {
+    "a conditional comment" : {
+      "haml" : "/[if IE]\n  %p a",
+      "html" : "<!--[if IE]>\n  <p>a</p>\n<![endif]-->"
+    }
+  },
+
+  "internal filters": {
+
+    "content in an 'escaped' filter" : {
+      "haml" : ":escaped\n  <&\">",
+      "html" : "&lt;&amp;&quot;&gt;"
+    },
+
+    "content in a 'preserve' filter" : {
+      "haml" : ":preserve\n  hello\n\n%p",
+      "html" : "hello&#x000A;\n<p></p>"
+    },
+
+    "content in a 'plain' filter" : {
+      "haml" : ":plain\n  hello\n\n%p",
+      "html" : "hello\n<p></p>"
+    },
+
+    "content in a 'javascript' filter" : {
+      "haml" : ":javascript\n  a();\n%p",
+      "html" : "<script type='text/javascript'>\n  //<![CDATA[\n    a();\n  //]]>\n</script>\n<p></p>"
+    }
+
+  },
+
+  "interpolation": {
+
+    "interpolation inside inline content" : {
+      "haml" : "%p #{var}",
+      "html" : "<p>value</p>",
+      "locals" : {
+        "var" : "value"
+      }
+    },
+
+    "no interpolation when escaped" : {
+      "haml" : "%p \\#{var}",
+      "html" : "<p>#{var}</p>"
+    },
+
+    "interpolation when the escape character is escaped" : {
+      "haml" : "%p \\\\#{var}",
+      "html" : "<p>\\value</p>",
+      "locals" : {
+        "var" : "value"
+      }
+    },
+
+    "interpolation inside filtered content" : {
+      "haml" : ":plain\n  #{var} interpolated: #{var}",
+      "html" : "value interpolated: value",
+      "locals" : {
+        "var" : "value"
+      }
+    }
+
+  },
+
+  "HTML escaping" : {
+
+    "code following '&='" : {
+      "haml" : "&= '<\"&>'",
+      "html" : "&lt;&quot;&amp;&gt;"
+    },
+
+    "code following '=' when escape_haml is set to true" : {
+      "haml" : "= '<\"&>'",
+      "html" : "&lt;&quot;&amp;&gt;",
+      "config" : {
+        "escape_html" : "true"
+      }
+    },
+
+    "code following '!=' when escape_haml is set to true" : {
+      "haml" : "!= '<\"&>'",
+      "html" : "<\"&>",
+      "config" : {
+        "escape_html" : "true"
+      }
+    }
+
+  },
+
+  "Boolean attributes" : {
+
+    "boolean attribute with XHTML" : {
+      "haml" : "%input(checked=true)",
+      "html" : "<input checked='checked' />",
+      "config" : {
+        "format" : "xhtml"
+      }
+    },
+
+    "boolean attribute with HTML" : {
+      "haml" : "%input(checked=true)",
+      "html" : "<input checked>",
+      "config" : {
+        "format" : "html5"
+      }
+    }
+  }
+
+}