haml 2.0.10 → 2.2.0

data/lib/sass/tree/prop_node.rb

@@ -0,0 +1,109 @@
+module Sass::Tree
+  # A static node reprenting a CSS property.
+  #
+  # @see Sass::Tree
+  class PropNode < Node
+    # The name of the property.
+    #
+    # @return [String]
+    attr_accessor :name
+
+    # The value of the property,
+    # either a plain string or a SassScript parse tree.
+    #
+    # @return [String, Script::Node]
+    attr_accessor :value
+
+    # @param name [String] See \{#name}
+    # @param value [String] See \{#value}
+    # @param prop_syntax [Symbol] `:new` if this property uses `a: b`-style syntax,
+    #   `:old` if it uses `:a b`-style syntax
+    def initialize(name, value, prop_syntax)
+      @name = name
+      @value = value
+      @prop_syntax = prop_syntax
+      super()
+    end
+
+    # Compares the names and values of two properties.
+    #
+    # @param other [Object] The object to compare with
+    # @return [Boolean] Whether or not this node and the other object
+    #   are the same
+    def ==(other)
+      self.class == other.class && name == other.name && value == other.value && super
+    end
+
+    # Computes the CSS for the property.
+    #
+    # @param tabs [Fixnum] The level of indentation for the CSS
+    # @param parent_name [String] The name of the parent property (e.g. `text`) or nil
+    # @return [String] The resulting CSS
+    # @raise [Sass::SyntaxError] if the property uses invalid syntax
+    def to_s(tabs, parent_name = nil)
+      if @options[:property_syntax] == :old && @prop_syntax == :new
+        raise Sass::SyntaxError.new("Illegal property syntax: can't use new syntax when :property_syntax => :old is set.")
+      elsif @options[:property_syntax] == :new && @prop_syntax == :old
+        raise Sass::SyntaxError.new("Illegal property syntax: can't use old syntax when :property_syntax => :new is set.")
+      end
+
+      if value[-1] == ?;
+        raise Sass::SyntaxError.new("Invalid property: #{declaration.dump} (no \";\" required at end-of-line).", @line)
+      end
+      real_name = name
+      real_name = "#{parent_name}-#{real_name}" if parent_name
+      
+      if value.empty? && children.empty?
+        raise Sass::SyntaxError.new("Invalid property: #{declaration.dump} (no value).", @line)
+      end
+      
+      join_string = case style
+                    when :compact; ' '
+                    when :compressed; ''
+                    else "\n"
+                    end
+      spaces = '  ' * (tabs - 1)
+      to_return = ''
+      if !value.empty?
+        to_return << "#{spaces}#{real_name}:#{style == :compressed ? '' : ' '}#{value};#{join_string}"
+      end
+      
+      children.each do |kid|
+        next if kid.invisible?
+        to_return << kid.to_s(tabs, real_name) << join_string
+      end
+      
+      (style == :compressed && parent_name) ? to_return : to_return[0...-1]
+    end
+
+    protected
+
+    # Runs any SassScript that may be embedded in the property.
+    #
+    # @param environment [Sass::Environment] The lexical environment containing
+    #   variable and mixin values
+    def perform!(environment)
+      @name = interpolate(@name, environment)
+      @value = @value.is_a?(String) ? interpolate(@value, environment) : @value.perform(environment).to_s
+      super
+    end
+
+    # Returns an error message if the given child node is invalid,
+    # and false otherwise.
+    #
+    # {PropNode} only allows other {PropNode}s and {CommentNode}s as children.
+    # @param child [Tree::Node] A potential child node
+    # @return [String] An error message if the child is invalid, or nil otherwise
+    def invalid_child?(child)
+      if !child.is_a?(PropNode) && !child.is_a?(CommentNode)
+        "Illegal nesting: Only properties may be nested beneath properties."
+      end
+    end
+
+    private
+
+    def declaration
+      @prop_syntax == :new ? "#{name}: #{value}" : ":#{name} #{value}"
+    end
+  end
+end

data/lib/sass/tree/rule_node.rb

@@ -1,93 +1,220 @@
-require 'sass/tree/node'
-require 'sass/tree/attr_node'
+require 'pathname'
 
 module Sass::Tree
-  class RuleNode < ValueNode
+  class RuleNode < Node
     # The character used to include the parent selector
     PARENT = '&'
 
-    alias_method :rule, :value
-    alias_method :rule=, :value=
+    # The CSS selectors for this rule.
+    # Each string is a selector line, and the lines are meant to be separated by commas.
+    # For example,
+    #
+    #     foo, bar, baz,
+    #     bip, bop, bup
+    #
+    # would be
+    #
+    #     ["foo, bar, baz",
+    #      "bip, bop, bup"]
+    #
+    # @return [Array<String>]
+    attr_accessor :rules
 
-    def ==(other)
-      self.class == other.class && rules == other.rules && super
+    # The CSS selectors for this rule,
+    # parsed for commas and parent-references.
+    # It's only set once {Tree::Node#perform} has been called.
+    #
+    # It's an array of arrays of arrays.
+    # The first level of arrays represents distinct lines in the Sass file;
+    # the second level represents comma-separated selectors;
+    # the third represents structure within those selectors,
+    # currently only parent-refs (represented by `:parent`).
+    # For example,
+    #
+    #     &.foo, bar, baz,
+    #     bip, &.bop, bup
+    #
+    # would be
+    #
+    #     [[[:parent, "foo"], ["bar"], ["baz"]],
+    #      [["bip"], [:parent, "bop"], ["bup"]]]
+    #
+    # @return [Array<Array<Array<String|Symbol>>>]
+    attr_accessor :parsed_rules
+
+    # @param rule [String] The first CSS rule. See \{#rules}
+    def initialize(rule)
+      @rules = [rule]
+      super()
     end
 
-    def rules
-      Array(rule)
+    # Compares the contents of two rules.
+    #
+    # @param other [Object] The object to compare with
+    # @return [Boolean] Whether or not this node and the other object
+    #   are the same
+    def ==(other)
+      self.class == other.class && rules == other.rules && super
     end
 
+    # Adds another {RuleNode}'s rules to this one's.
+    #
+    # @param node [RuleNode] The other node
     def add_rules(node)
-      self.rule = rules
-      self.rule += node.rules
+      @rules += node.rules
     end
 
+    # @return [Boolean] Whether or not this rule is continued on the next line
     def continued?
-      rule[-1] == ?,
+      @rules.last[-1] == ?,
     end
 
+    # Computes the CSS for the rule.
+    #
+    # @param tabs [Fixnum] The level of indentation for the CSS
+    # @param super_rules [Array<Array<String>>] The rules for the parent node
+    #   (see \{#rules}), or `nil` if there are no parents
+    # @return [String] The resulting CSS
+    # @raise [Sass::SyntaxError] if the rule has no parents but uses `&`
     def to_s(tabs, super_rules = nil)
-      attributes = []
+      resolved_rules = resolve_parent_refs(super_rules)
+
+      properties = []
       sub_rules = []
 
-      rule_split = /\s*,\s*/
-      rule_separator = @style == :compressed ? ',' : ', '
-      line_separator = [:nested, :expanded].include?(@style) ? ",\n" : rule_separator
+      rule_separator = style == :compressed ? ',' : ', '
+      line_separator = [:nested, :expanded].include?(style) ? ",\n" : rule_separator
       rule_indent = '  ' * (tabs - 1)
-      total_rule = if super_rules
-        super_rules.split(",\n").map do |super_line|
-          super_line.strip.split(rule_split).map do |super_rule|
-            self.rules.map do |line|
-              rule_indent + line.gsub(/,$/, '').split(rule_split).map do |rule|
-                if rule.include?(PARENT)
-                  rule.gsub(PARENT, super_rule)
-                else
-                  "#{super_rule} #{rule}"
-                end
-              end.join(rule_separator)
-            end.join(line_separator)
-          end.join(rule_separator)
-        end.join(line_separator)
-      elsif self.rules.any? { |r| r.include?(PARENT) }
-        raise Sass::SyntaxError.new("Base-level rules cannot contain the parent-selector-referencing character '#{PARENT}'.", line)
-      else
-        per_rule_indent, total_indent = [:nested, :expanded].include?(@style) ? [rule_indent, ''] : ['', rule_indent]
-        total_indent + self.rules.map do |r|
-          per_rule_indent + r.gsub(/,$/, '').gsub(rule_split, rule_separator).rstrip
-        end.join(line_separator)
-      end
+      per_rule_indent, total_indent = [:nested, :expanded].include?(style) ? [rule_indent, ''] : ['', rule_indent]
+
+      total_rule = total_indent + resolved_rules.map do |line|
+        per_rule_indent + line.join(rule_separator)
+      end.join(line_separator)
 
       children.each do |child|
+        next if child.invisible?
         if child.is_a? RuleNode
           sub_rules << child
         else
-          attributes << child
+          properties << child
         end
       end
 
       to_return = ''
-      if !attributes.empty?
+      if !properties.empty?
         old_spaces = '  ' * (tabs - 1)
         spaces = '  ' * tabs
-        if @style == :compact
-          attributes = attributes.map { |a| a.to_s(1) }.join(' ')
-          to_return << "#{total_rule} { #{attributes} }\n"
-        elsif @style == :compressed
-          attributes = attributes.map { |a| a.to_s(1) }.join(';')
-          to_return << "#{total_rule}{#{attributes}}"
+        if @options[:line_comments] && style != :compressed
+          to_return << "#{old_spaces}/* line #{line}"
+
+          if filename
+            relative_filename = if @options[:css_filename]
+              begin
+                Pathname.new(filename).relative_path_from(  
+                  Pathname.new(File.dirname(@options[:css_filename]))).to_s
+              rescue ArgumentError
+                nil
+              end
+            end
+            relative_filename ||= filename
+            to_return << ", #{relative_filename}"
+          end
+
+          to_return << " */\n"
+        end
+
+        if style == :compact
+          properties = properties.map { |a| a.to_s(1) }.select{|a| a && a.length > 0}.join(' ')
+          to_return << "#{total_rule} { #{properties} }\n"
+        elsif style == :compressed
+          properties = properties.map { |a| a.to_s(1) }.select{|a| a && a.length > 0}.join(';')
+          to_return << "#{total_rule}{#{properties}}"
         else
-          attributes = attributes.map { |a| a.to_s(tabs + 1) }.join("\n")
-          end_attrs = (@style == :expanded ? "\n" + old_spaces : ' ')
-          to_return << "#{total_rule} {\n#{attributes}#{end_attrs}}\n"
+          properties = properties.map { |a| a.to_s(tabs + 1) }.select{|a| a && a.length > 0}.join("\n")
+          end_props = (style == :expanded ? "\n" + old_spaces : ' ')
+          to_return << "#{total_rule} {\n#{properties}#{end_props}}\n"
         end
       end
 
-      tabs += 1 unless attributes.empty? || @style != :nested
+      tabs += 1 unless properties.empty? || style != :nested
       sub_rules.each do |sub|
-        to_return << sub.to_s(tabs, total_rule)
+        to_return << sub.to_s(tabs, resolved_rules)
       end
 
       to_return
     end
+
+    protected
+
+    # Runs any SassScript that may be embedded in the rule,
+    # and parses the selectors for commas.
+    #
+    # @param environment [Sass::Environment] The lexical environment containing
+    #   variable and mixin values
+    def perform!(environment)
+      @parsed_rules = @rules.map {|r| parse_selector(interpolate(r, environment))}
+      super
+    end
+
+    private
+
+    def resolve_parent_refs(super_rules)
+      if super_rules.nil?
+        return @parsed_rules.map do |line|
+          line.map do |rule|
+            if rule.include?(:parent)
+              raise Sass::SyntaxError.new("Base-level rules cannot contain the parent-selector-referencing character '#{PARENT}'.", self.line)
+            end
+
+            rule.join
+          end.compact
+        end
+      end
+
+      new_rules = []
+      super_rules.each do |super_line|
+        @parsed_rules.each do |line|
+          new_rules << []
+
+          super_line.each do |super_rule|
+            line.each do |rule|
+              rule = [:parent, " ", *rule] unless rule.include?(:parent)
+
+              new_rules.last << rule.map do |segment|
+                next segment unless segment == :parent
+                super_rule
+              end.join
+            end
+          end
+        end
+      end
+      new_rules
+    end
+
+    def parse_selector(text)
+      scanner = StringScanner.new(text)
+      rules = [[]]
+
+      while scanner.rest?
+        rules.last << scanner.scan(/[^",&]*/)
+        case scanner.scan(/./)
+        when '&'; rules.last << :parent
+        when ','
+          scanner.scan(/\s*/)
+          rules << [] if scanner.rest?
+        when '"'
+          rules.last << '"' << scanner.scan(/([^"\\]|\\.)*/)
+          # We don't want to enforce that strings are closed,
+          # but we do want to consume quotes or trailing backslashes.
+          rules.last << scanner.scan(/./) if scanner.rest?
+        end
+      end
+
+      rules.map! do |l|
+        Haml::Util.merge_adjacent_strings(l).reject {|r| r.is_a?(String) && r.empty?}
+      end
+
+      rules
+    end
   end
 end

data/lib/sass/tree/variable_node.rb

@@ -0,0 +1,34 @@
+module Sass
+  module Tree
+    # A dynamic node representing a variable definition.
+    #
+    # @see Sass::Tree
+    class VariableNode < Node
+      # @param name [String] The name of the variable
+      # @param expr [Script::Node] The parse tree for the initial variable value
+      # @param guarded [Boolean] Whether this is a guarded variable assignment (`||=`)
+      def initialize(name, expr, guarded)
+        @name = name
+        @expr = expr
+        @guarded = guarded
+        super()
+      end
+
+      protected
+
+      # Loads the new variable value into the environment.
+      #
+      # @param environment [Sass::Environment] The lexical environment containing
+      #   variable and mixin values
+      def _perform(environment)
+        if @guarded && environment.var(@name).nil?
+          environment.set_var(@name, @expr.perform(environment))
+        elsif !@guarded
+          environment.set_var(@name, @expr.perform(environment))
+        end
+
+        []
+      end
+    end
+  end
+end

data/lib/sass/tree/while_node.rb

@@ -0,0 +1,31 @@
+require 'sass/tree/node'
+
+module Sass::Tree
+  # A dynamic node representing a Sass `@while` loop.
+  #
+  # @see Sass::Tree
+  class WhileNode < Node
+    # @param expr [Script::Node] The parse tree for the continue expression
+    def initialize(expr)
+      @expr = expr
+      super()
+    end
+
+    protected
+
+    # Runs the child nodes until the continue expression becomes false.
+    #
+    # @param environment [Sass::Environment] The lexical environment containing
+    #   variable and mixin values
+    # @return [Array<Tree::Node>] The resulting static nodes
+    # @see Sass::Tree
+    def _perform(environment)
+      children = []
+      new_environment = Sass::Environment.new(environment)
+      while @expr.perform(environment).to_bool
+        children += perform_children(new_environment)
+      end
+      children
+    end
+  end
+end

data/test/haml/engine_test.rb

@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
+# -*- coding: utf-8 -*-
 require File.dirname(__FILE__) + '/../test_helper'
 
 class EngineTest < Test::Unit::TestCase
@@ -17,39 +18,53 @@ class EngineTest < Test::Unit::TestCase
     "~" => "There's no Ruby code for ~ to evaluate.",
     "=" => "There's no Ruby code for = to evaluate.",
     "%p/\n  a" => "Illegal nesting: nesting within a self-closing tag is illegal.",
-    "%p\n\ta" => <<END.strip,
-A tab character was used for indentation. Haml must be indented using two spaces.
-Are you sure you have soft tabs enabled in your editor?
-END
-    "%p\n a" => "1 space was used for indentation. Haml must be indented using two spaces.",
-    "%p\n   a" => "3 spaces were used for indentation. Haml must be indented using two spaces.",
-    "%p\n    a" => "4 spaces were used for indentation. Haml must be indented using two spaces.",
     ":a\n  b" => ['Filter "a" is not defined.', 1],
     ":a= b" => 'Invalid filter name ":a= b".',
     "." => "Illegal element: classes and ids must have values.",
     ".#" => "Illegal element: classes and ids must have values.",
     ".{} a" => "Illegal element: classes and ids must have values.",
+    ".() a" => "Illegal element: classes and ids must have values.",
     ".= a" => "Illegal element: classes and ids must have values.",
     "%p..a" => "Illegal element: classes and ids must have values.",
     "%a/ b" => "Self-closing tags can't have content.",
+    "%p{:a => 'b',\n:c => 'd'}/ e" => ["Self-closing tags can't have content.", 2],
+    "%p{:a => 'b',\n:c => 'd'}=" => ["There's no Ruby code for = to evaluate.", 2],
+    "%p.{:a => 'b',\n:c => 'd'} e" => ["Illegal element: classes and ids must have values.", 1],
+    "%p{:a => 'b',\n:c => 'd',\n:e => 'f'}\n%p/ a" => ["Self-closing tags can't have content.", 4],
+    "%p{:a => 'b',\n:c => 'd',\n:e => 'f'}\n- raise 'foo'" => ["foo", 4],
+    "%p{:a => 'b',\n:c => raise('foo'),\n:e => 'f'}" => ["foo", 2],
+    "%p{:a => 'b',\n:c => 'd',\n:e => raise('foo')}" => ["foo", 3],
     " %p foo" => "Indenting at the beginning of the document is illegal.",
     "  %p foo" => "Indenting at the beginning of the document is illegal.",
     "- end" => "You don't need to use \"- end\" in Haml. Use indentation instead:\n- if foo?\n  %strong Foo!\n- else\n  Not foo.",
     " \n\t\n %p foo" => ["Indenting at the beginning of the document is illegal.", 3],
+    "\n\n %p foo" => ["Indenting at the beginning of the document is illegal.", 3],
+    "%p\n  foo\n foo" => ["Inconsistent indentation: 1 space was used for indentation, but the rest of the document was indented using 2 spaces.", 3],
+    "%p\n  foo\n%p\n foo" => ["Inconsistent indentation: 1 space was used for indentation, but the rest of the document was indented using 2 spaces.", 4],
+    "%p\n\t\tfoo\n\tfoo" => ["Inconsistent indentation: 1 tab was used for indentation, but the rest of the document was indented using 2 tabs.", 3],
+    "%p\n  foo\n   foo" => ["Inconsistent indentation: 3 spaces were used for indentation, but the rest of the document was indented using 2 spaces.", 3],
+    "%p\n  foo\n  %p\n   bar" => ["Inconsistent indentation: 3 spaces were used for indentation, but the rest of the document was indented using 2 spaces.", 4],
+    "%p\n  :plain\n     bar\n   \t  baz" => ['Inconsistent indentation: "   \t  " was used for indentation, but the rest of the document was indented using 2 spaces.', 4],
+    "%p\n  foo\n%p\n    bar" => ["The line was indented 2 levels deeper than the previous line.", 4],
+    "%p\n  foo\n  %p\n        bar" => ["The line was indented 3 levels deeper than the previous line.", 4],
+    "%p\n \tfoo" => ["Indentation can't use both tabs and spaces.", 2],
+    "%p(" => "Invalid attribute list: \"(\".",
+    "%p(foo=\nbar)" => ["Invalid attribute list: \"(foo=\".", 1],
+    "%p(foo=)" => "Invalid attribute list: \"(foo=)\".",
+    "%p(foo 'bar')" => "Invalid attribute list: \"(foo 'bar')\".",
+    "%p(foo 'bar'\nbaz='bang')" => ["Invalid attribute list: \"(foo 'bar'\".", 1],
+    "%p(foo='bar'\nbaz 'bang'\nbip='bop')" => ["Invalid attribute list: \"(foo='bar' baz 'bang'\".", 2],
 
     # Regression tests
     "- raise 'foo'\n\n\n\nbar" => ["foo", 1],
     "= 'foo'\n-raise 'foo'" => ["foo", 2],
     "\n\n\n- raise 'foo'" => ["foo", 4],
+    "%p foo |\n   bar |\n   baz |\nbop\n- raise 'foo'" => ["foo", 5],
     "foo\n\n\n  bar" => ["Illegal nesting: nesting within plain text is illegal.", 4],
     "%p/\n\n  bar" => ["Illegal nesting: nesting within a self-closing tag is illegal.", 3],
     "%p foo\n\n  bar" => ["Illegal nesting: content can't be both given on the same line as %p and nested within it.", 3],
     "/ foo\n\n  bar" => ["Illegal nesting: nesting within a tag that already has content is illegal.", 3],
     "!!!\n\n  bar" => ["Illegal nesting: nesting within a header command is illegal.", 3],
-    "foo\n\n\n\tbar" => [<<END.strip, 4],
-A tab character was used for indentation. Haml must be indented using two spaces.
-Are you sure you have soft tabs enabled in your editor?
-END
     "foo\n:ruby\n  1\n  2\n  3\n- raise 'foo'" => ["foo", 6],
   }
 
@@ -70,7 +85,20 @@ END
     end
     Haml::Engine.new(text, options)
   end
-  
+
+  def test_empty_render
+    assert_equal "", render("")
+  end
+
+  def test_flexible_tabulation
+    assert_equal("<p>\n  foo\n</p>\n<q>\n  bar\n  <a>\n    baz\n  </a>\n</q>\n",
+                 render("%p\n foo\n%q\n bar\n %a\n  baz"))
+    assert_equal("<p>\n  foo\n</p>\n<q>\n  bar\n  <a>\n    baz\n  </a>\n</q>\n",
+                 render("%p\n\tfoo\n%q\n\tbar\n\t%a\n\t\tbaz"))
+    assert_equal("<p>\n      \t \t bar\n   baz\n</p>\n",
+                 render("%p\n  :plain\n        \t \t bar\n     baz"))
+  end
+
   def test_empty_render_should_remain_empty
     assert_equal('', render(''))
   end
@@ -109,14 +137,19 @@ END
     assert_equal("<strong>Hi there!</strong>\n", engine.to_html)
   end
 
-  def test_double_equals
-    assert_equal("<p>Hello World</p>\n", render('%p== Hello #{who}', :locals => {:who => 'World'}))
-    assert_equal("<p>\n  Hello World\n</p>\n", render("%p\n  == Hello \#{who}", :locals => {:who => 'World'}))
+  def test_interpolation
+    assert_equal("<p>Hello World</p>\n", render('%p Hello #{who}', :locals => {:who => 'World'}))
+    assert_equal("<p>\n  Hello World\n</p>\n", render("%p\n  Hello \#{who}", :locals => {:who => 'World'}))
   end
 
-  def test_double_equals_in_the_middle_of_a_string
+  def test_interpolation_in_the_middle_of_a_string
     assert_equal("\"title 'Title'. \"\n",
-                 render("== \"title '\#{\"Title\"}'. \""))
+                 render("\"title '\#{\"Title\"}'. \""))
+  end
+
+  def test_interpolation_at_the_beginning_of_a_line
+    assert_equal("<p>2</p>\n", render('%p #{1 + 1}'))
+    assert_equal("<p>\n  2\n</p>\n", render("%p\n  \#{1 + 1}"))
   end
 
   def test_nil_tag_value_should_render_as_empty
@@ -135,6 +168,13 @@ END
     assert_equal("<img alt='' src='/foo.png' />\n", render("%img{:width => nil, :src => '/foo.png', :alt => String.new}"))
   end
 
+  def test_attribute_hash_with_newlines
+    assert_equal("<p a='b' c='d'>foop</p>\n", render("%p{:a => 'b',\n   :c => 'd'} foop"))
+    assert_equal("<p a='b' c='d'>\n  foop\n</p>\n", render("%p{:a => 'b',\n   :c => 'd'}\n  foop"))
+    assert_equal("<p a='b' c='d' />\n", render("%p{:a => 'b',\n   :c => 'd'}/"))
+    assert_equal("<p a='b' c='d' e='f'></p>\n", render("%p{:a => 'b',\n   :c => 'd',\n   :e => 'f'}"))
+  end
+
   def test_attr_hashes_not_modified
     hash = {:color => 'red'}
     assert_equal(<<HTML, render(<<HAML, :locals => {:hash => hash}))
@@ -188,8 +228,19 @@ SOURCE
                  render("%p{:foo => 'bar', :bar => false, :baz => 'false'}", :format => :xhtml))
   end
 
+  def test_both_whitespace_nukes_work_together
+    assert_equal(<<RESULT, render(<<SOURCE))
+<p><q>Foo
+  Bar</q></p>
+RESULT
+%p
+  %q><= "Foo\\nBar"
+SOURCE
+  end
+
+  # Regression tests
+
   def test_whitespace_nuke_with_both_newlines
-    # Regression test
     assert_equal("<p>foo</p>\n", render('%p<= "\nfoo\n"'))
     assert_equal(<<HTML, render(<<HAML))
 <p>
@@ -201,17 +252,6 @@ HTML
 HAML
   end
 
-  def test_both_whitespace_nukes_work_together
-    assert_equal(<<RESULT, render(<<SOURCE))
-<p><q>Foo
-  Bar</q></p>
-RESULT
-%p
-  %q><= "Foo\\nBar"
-SOURCE
-  end
-
-  # Mostly a regression test
   def test_both_case_indentation_work_with_deeply_nested_code
     result = <<RESULT
 <h2>
@@ -238,6 +278,87 @@ HAML
 HAML
   end
 
+  def test_equals_block_with_ugly
+    assert_equal("foo\n", render(<<HAML, :ugly => true))
+= capture_haml do
+  foo
+HAML
+  end
+
+  def test_plain_equals_with_ugly
+    assert_equal("foo\nbar\n", render(<<HAML, :ugly => true))
+= "foo"
+bar
+HAML
+  end
+
+  def test_inline_if
+    assert_equal(<<HTML, render(<<HAML))
+<p>One</p>
+<p></p>
+<p>Three</p>
+HTML
+- for name in ["One", "Two", "Three"]
+  %p= name unless name == "Two"
+HAML
+  end
+
+  def test_end_with_method_call
+    assert_equal(<<HTML, render(<<HAML))
+2|3|4
+b-a-r
+HTML
+= [1, 2, 3].map do |i|
+  - i + 1
+- end.join("|")
+= "bar".gsub(/./) do |s|
+  - s + "-"
+- end.gsub(/-$/) do |s|
+  - ''
+HAML
+  end
+
+  def test_multiline_with_colon_after_filter
+    assert_equal(<<HTML, render(<<HAML))
+Foo
+Bar
+HTML
+:plain
+  Foo
+= { :a => "Bar",      |
+    :b => "Baz" }[:a] |
+HAML
+    assert_equal(<<HTML, render(<<HAML))
+
+Bar
+HTML
+:plain
+= { :a => "Bar",      |
+    :b => "Baz" }[:a] |
+HAML
+  end
+
+  def test_multiline_in_filter
+    assert_equal(<<HTML, render(<<HAML))
+Foo |
+Bar |
+Baz
+HTML
+:plain
+  Foo |
+  Bar |
+  Baz
+HAML
+  end
+
+  def test_curly_brace
+    assert_equal(<<HTML, render(<<HAML))
+Foo { Bar
+HTML
+== Foo { Bar
+HAML
+  end
+
   # HTML escaping tests
 
   def test_ampersand_equals_should_escape
@@ -281,32 +402,57 @@ HAML
     assert_equal("<img alt='' src='foo&#x000A;.png' />\n",
                  render("%img{:width => nil, :src => \"foo\\n.png\", :alt => String.new}"))
   end
-  
-  def test_string_interpolation_should_be_esaped
+
+  def test_string_double_equals_should_be_esaped
     assert_equal("<p>4&amp;3</p>\n", render("%p== \#{2+2}&\#{2+1}", :escape_html => true))
     assert_equal("<p>4&3</p>\n", render("%p== \#{2+2}&\#{2+1}", :escape_html => false))
   end
 
-  def test_escaped_inline_string_interpolation
+  def test_escaped_inline_string_double_equals
     assert_equal("<p>4&amp;3</p>\n", render("%p&== \#{2+2}&\#{2+1}", :escape_html => true))
     assert_equal("<p>4&amp;3</p>\n", render("%p&== \#{2+2}&\#{2+1}", :escape_html => false))
   end
 
-  def test_unescaped_inline_string_interpolation
+  def test_unescaped_inline_string_double_equals
     assert_equal("<p>4&3</p>\n", render("%p!== \#{2+2}&\#{2+1}", :escape_html => true))
     assert_equal("<p>4&3</p>\n", render("%p!== \#{2+2}&\#{2+1}", :escape_html => false))
   end
 
-  def test_escaped_string_interpolation
+  def test_escaped_string_double_equals
     assert_equal("<p>\n  4&amp;3\n</p>\n", render("%p\n  &== \#{2+2}&\#{2+1}", :escape_html => true))
     assert_equal("<p>\n  4&amp;3\n</p>\n", render("%p\n  &== \#{2+2}&\#{2+1}", :escape_html => false))
   end
 
-  def test_unescaped_string_interpolation
+  def test_unescaped_string_double_equals
     assert_equal("<p>\n  4&3\n</p>\n", render("%p\n  !== \#{2+2}&\#{2+1}", :escape_html => true))
     assert_equal("<p>\n  4&3\n</p>\n", render("%p\n  !== \#{2+2}&\#{2+1}", :escape_html => false))
   end
 
+  def test_string_interpolation_should_be_esaped
+    assert_equal("<p>4&amp;3</p>\n", render("%p \#{2+2}&\#{2+1}", :escape_html => true))
+    assert_equal("<p>4&3</p>\n", render("%p \#{2+2}&\#{2+1}", :escape_html => false))
+  end
+
+  def test_escaped_inline_string_interpolation
+    assert_equal("<p>4&amp;3</p>\n", render("%p& \#{2+2}&\#{2+1}", :escape_html => true))
+    assert_equal("<p>4&amp;3</p>\n", render("%p& \#{2+2}&\#{2+1}", :escape_html => false))
+  end
+
+  def test_unescaped_inline_string_interpolation
+    assert_equal("<p>4&3</p>\n", render("%p! \#{2+2}&\#{2+1}", :escape_html => true))
+    assert_equal("<p>4&3</p>\n", render("%p! \#{2+2}&\#{2+1}", :escape_html => false))
+  end
+
+  def test_escaped_string_interpolation
+    assert_equal("<p>\n  4&amp;3\n</p>\n", render("%p\n  & \#{2+2}&\#{2+1}", :escape_html => true))
+    assert_equal("<p>\n  4&amp;3\n</p>\n", render("%p\n  & \#{2+2}&\#{2+1}", :escape_html => false))
+  end
+
+  def test_unescaped_string_interpolation
+    assert_equal("<p>\n  4&3\n</p>\n", render("%p\n  ! \#{2+2}&\#{2+1}", :escape_html => true))
+    assert_equal("<p>\n  4&3\n</p>\n", render("%p\n  ! \#{2+2}&\#{2+1}", :escape_html => false))
+  end
+
   def test_scripts_should_respect_escape_html_option
     assert_equal("<p>\n  foo &amp; bar\n</p>\n", render("%p\n  = 'foo & bar'", :escape_html => true))
     assert_equal("<p>\n  foo & bar\n</p>\n", render("%p\n  = 'foo & bar'", :escape_html => false))
@@ -499,7 +645,7 @@ HAML
   end
 
   def test_unbalanced_brackets
-    render('== #{1 + 5} foo #{6 + 7 bar #{8 + 9}')
+    render('foo #{1 + 5} foo #{6 + 7 bar #{8 + 9}')
   rescue Haml::SyntaxError => e
     assert_equal("Unbalanced brackets.", e.message)
   end
@@ -665,4 +811,153 @@ END
   def test_html5_doctype
     assert_equal %{<!DOCTYPE html>\n}, render('!!!', :format => :html5)
   end
+
+  # New attributes
+
+  def test_basic_new_attributes
+    assert_equal("<a>bar</a>\n", render("%a() bar"))
+    assert_equal("<a href='foo'>bar</a>\n", render("%a(href='foo') bar"))
+    assert_equal("<a b='c' c='d' d='e'>baz</a>\n", render(%q{%a(b="c" c='d' d="e") baz}))
+  end
+
+  def test_new_attribute_ids
+    assert_equal("<div id='foo_bar'></div>\n", render("#foo(id='bar')"))
+    assert_equal("<div id='foo_bar_baz'></div>\n", render("#foo{:id => 'bar'}(id='baz')"))
+    assert_equal("<div id='foo_baz_bar'></div>\n", render("#foo(id='baz'){:id => 'bar'}"))
+    foo = User.new(42)
+    assert_equal("<div class='struct_user' id='foo_baz_bar_struct_user_42'></div>\n",
+      render("#foo(id='baz'){:id => 'bar'}[foo]", :locals => {:foo => foo}))
+    assert_equal("<div class='struct_user' id='foo_baz_bar_struct_user_42'></div>\n",
+      render("#foo(id='baz')[foo]{:id => 'bar'}", :locals => {:foo => foo}))
+    assert_equal("<div class='struct_user' id='foo_baz_bar_struct_user_42'></div>\n",
+      render("#foo[foo](id='baz'){:id => 'bar'}", :locals => {:foo => foo}))
+    assert_equal("<div class='struct_user' id='foo_bar_baz_struct_user_42'></div>\n",
+      render("#foo[foo]{:id => 'bar'}(id='baz')", :locals => {:foo => foo}))
+  end
+
+  def test_new_attribute_classes
+    assert_equal("<div class='bar foo'></div>\n", render(".foo(class='bar')"))
+    assert_equal("<div class='bar baz foo'></div>\n", render(".foo{:class => 'bar'}(class='baz')"))
+    assert_equal("<div class='bar baz foo'></div>\n", render(".foo(class='baz'){:class => 'bar'}"))
+    foo = User.new(42)
+    assert_equal("<div class='bar baz foo struct_user' id='struct_user_42'></div>\n",
+      render(".foo(class='baz'){:class => 'bar'}[foo]", :locals => {:foo => foo}))
+    assert_equal("<div class='bar baz foo struct_user' id='struct_user_42'></div>\n",
+      render(".foo[foo](class='baz'){:class => 'bar'}", :locals => {:foo => foo}))
+    assert_equal("<div class='bar baz foo struct_user' id='struct_user_42'></div>\n",
+      render(".foo[foo]{:class => 'bar'}(class='baz')", :locals => {:foo => foo}))
+  end
+
+  def test_dynamic_new_attributes
+    assert_equal("<a href='12'>bar</a>\n", render("%a(href=foo) bar", :locals => {:foo => 12}))
+    assert_equal("<a b='12' c='13' d='14'>bar</a>\n", render("%a(b=b c='13' d=d) bar", :locals => {:b => 12, :d => 14}))
+  end
+
+  def test_new_attribute_interpolation
+    assert_equal("<a href='12'>bar</a>\n", render('%a(href="1#{1 + 1}") bar'))
+    assert_equal("<a href='2: 2, 3: 3'>bar</a>\n", render(%q{%a(href='2: #{1 + 1}, 3: #{foo}') bar}, :locals => {:foo => 3}))
+    assert_equal(%Q{<a href='1\#{1 + 1}'>bar</a>\n}, render('%a(href="1\#{1 + 1}") bar'))
+  end
+
+  def test_truthy_new_attributes
+    assert_equal("<a href='href'>bar</a>\n", render("%a(href) bar"))
+    assert_equal("<a bar='baz' href>bar</a>\n", render("%a(href bar='baz') bar", :format => :html5))
+    assert_equal("<a href='href'>bar</a>\n", render("%a(href=true) bar"))
+    assert_equal("<a>bar</a>\n", render("%a(href=false) bar"))
+  end
+
+  def test_new_attribute_parsing
+    assert_equal("<a a2='b2'>bar</a>\n", render("%a(a2=b2) bar", :locals => {:b2 => 'b2'}))
+    assert_equal(%Q{<a a='foo"bar'>bar</a>\n}, render(%q{%a(a="#{'foo"bar'}") bar})) #'
+    assert_equal(%Q{<a a="foo'bar">bar</a>\n}, render(%q{%a(a="#{"foo'bar"}") bar})) #'
+    assert_equal(%Q{<a a='foo"bar'>bar</a>\n}, render(%q{%a(a='foo"bar') bar}))
+    assert_equal(%Q{<a a="foo'bar">bar</a>\n}, render(%q{%a(a="foo'bar") bar}))
+    assert_equal("<a a:b='foo'>bar</a>\n", render("%a(a:b='foo') bar"))
+    assert_equal("<a a='foo' b='bar'>bar</a>\n", render("%a(a = 'foo' b = 'bar') bar"))
+    assert_equal("<a a='foo' b='bar'>bar</a>\n", render("%a(a = foo b = bar) bar", :locals => {:foo => 'foo', :bar => 'bar'}))
+    assert_equal("<a a='foo'>(b='bar')</a>\n", render("%a(a='foo')(b='bar')"))
+    assert_equal("<a a='foo)bar'>baz</a>\n", render("%a(a='foo)bar') baz"))
+    assert_equal("<a a='foo'>baz</a>\n", render("%a( a = 'foo' ) baz"))
+  end
+
+  def test_new_attribute_escaping
+    assert_equal(%Q{<a a='foo " bar'>bar</a>\n}, render(%q{%a(a="foo \" bar") bar}))
+    assert_equal(%Q{<a a='foo \\" bar'>bar</a>\n}, render(%q{%a(a="foo \\\\\" bar") bar}))
+
+    assert_equal(%Q{<a a="foo ' bar">bar</a>\n}, render(%q{%a(a='foo \' bar') bar}))
+    assert_equal(%Q{<a a="foo \\' bar">bar</a>\n}, render(%q{%a(a='foo \\\\\' bar') bar}))
+
+    assert_equal(%Q{<a a='foo \\ bar'>bar</a>\n}, render(%q{%a(a="foo \\\\ bar") bar}))
+    assert_equal(%Q{<a a='foo \#{1 + 1} bar'>bar</a>\n}, render(%q{%a(a="foo \#{1 + 1} bar") bar}))
+  end
+
+  def test_multiline_new_attribute
+    assert_equal("<a a='b' c='d'>bar</a>\n", render("%a(a='b'\n  c='d') bar"))
+    assert_equal("<a a='b' b='c' c='d' d='e' e='f' f='j'>bar</a>\n",
+      render("%a(a='b' b='c'\n  c='d' d=e\n  e='f' f='j') bar", :locals => {:e => 'e'}))
+  end
+
+  def test_new_and_old_attributes
+    assert_equal("<a a='b' c='d'>bar</a>\n", render("%a(a='b'){:c => 'd'} bar"))
+    assert_equal("<a a='b' c='d'>bar</a>\n", render("%a{:c => 'd'}(a='b') bar"))
+    assert_equal("<a a='b' c='d'>bar</a>\n", render("%a(c='d'){:a => 'b'} bar"))
+    assert_equal("<a a='b' c='d'>bar</a>\n", render("%a{:a => 'b'}(c='d') bar"))
+
+    assert_equal("<a a='d'>bar</a>\n", render("%a{:a => 'b'}(a='d') bar"))
+    assert_equal("<a a='b'>bar</a>\n", render("%a(a='d'){:a => 'b'} bar"))
+
+    assert_equal("<a a='b' b='c' c='d' d='e'>bar</a>\n",
+      render("%a{:a => 'b',\n:b => 'c'}(c='d'\nd='e') bar"))
+  end
+
+  # Encodings
+
+  unless Haml::Util.ruby1_8?
+    def test_default_encoding
+      assert_equal(Encoding.find("utf-8"), render(<<HAML.encode("us-ascii")).encoding)
+HTML
+%p bar
+%p foo
+HAML
+    end
+
+    def test_convert_template_render
+      assert_equal(<<HTML, render(<<HAML.encode("iso-8859-1"), :encoding => "utf-8"))
+<p>bâr</p>
+<p>föö</p>
+HTML
+%p bâr
+%p föö
+HAML
+    end
+
+    def test_convert_template_render_proc
+      assert_converts_template_properly {|e| e.render_proc.call}
+    end
+
+    def test_convert_template_render
+      assert_converts_template_properly {|e| e.render}
+    end
+
+    def test_convert_template_def_method
+      assert_converts_template_properly do |e|
+        o = Object.new
+        e.def_method(o, :render)
+        o.render
+      end
+    end
+  end
+
+  private
+
+  def assert_converts_template_properly
+    engine = Haml::Engine.new(<<HAML.encode("iso-8859-1"), :encoding => "utf-8")
+%p bâr
+%p föö
+HAML
+    assert_equal(<<HTML, yield(engine))
+<p>bâr</p>
+<p>föö</p>
+HTML
+  end
 end