haml 3.2.0.alpha.14 → 3.2.0.beta.1

data/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 ## 3.2.0 (Unreleased)
 
+* HTML5 is now the default output format rather than XHTML. This was already
+  the default on Rails 3+, so many users will notice no difference.
+
+* The :javascript and :css filters no longer add CDATA tags when the format is
+  html4 or html5. This can be overridden by setting the `cdata` option to
+  `true`. CDATA tags are always added when the format is xhtml.
+
 * HTML2Haml has been extracted to a separate gem, creatively named "html2haml".
 
 * Haml's internals have been refactored to move the parser, compiler and options

data/REFERENCE.md

@@ -1,7 +1,7 @@
 # Haml (XHTML Abstraction Markup Language)
 
-Haml is a markup language that's used to cleanly and simply describe the XHTML
-of any web document, without the use of inline code. Haml functions as a
+Haml is a markup language that's used to cleanly and simply describe the HTML of
+any web document, without the use of inline code. Haml functions as a
 replacement for inline page templating systems such as PHP, ERB, and ASP.
 However, Haml avoids the need for explicitly coding HTML into the template,
 because it is actually an abstract description of the HTML, with some code to
@@ -651,8 +651,8 @@ is compiled to:
     </html>
 
 You can also specify the specific doctype after the `!!!` When the
-[`:format`](#format-option) is set to `:xhtml` (the default except in Rails 3),
-the following doctypes are supported:
+[`:format`](#format-option) is set to `:xhtml`. The following doctypes are
+supported:
 
 `!!!`
 : XHTML 1.0 Transitional<br/>
@@ -1092,8 +1092,9 @@ Tilt.
 
 {#css-filter}
 ### `:css`
-Surrounds the filtered text with `<style>` and CDATA tags. Useful for including
-inline CSS.
+Surrounds the filtered text with `<style>` and (optionally) CDATA tags. Useful
+for including inline CSS. Use the {Haml::Options#cdata `:cdata` option} to
+control when CDATA tags are added.
 
 {#erb-filter}
 ### `:erb`
@@ -1109,8 +1110,9 @@ before placing it in the document.
 
 {#javascript-filter}
 ### `:javascript`
-Surrounds the filtered text with `<script>` and CDATA tags.
-Useful for including inline Javascript.
+Surrounds the filtered text with `<script>` and (optionally) CDATA tags.
+Useful for including inline Javascript. Use the {Haml::Options#cdata `:cdata`
+option} to control when CDATA tags are added.
 
 {#less-filter}
 ### `:less`
@@ -1230,7 +1232,7 @@ For example, tags like `pre` and `textarea` are whitespace-sensitive;
 indenting the text makes them render wrong.
 
 Haml deals with this by "preserving" newlines before they're put into the document --
-converting them to the XHTML whitespace escape code, `&#x000A;`.
+converting them to the HTML whitespace escape code, `&#x000A;`.
 Then Haml won't try to re-format the indentation.
 
 Literal `textarea` and `pre` tags automatically preserve content given through `=`.

data/lib/haml/compiler.rb

@@ -260,9 +260,9 @@ END
       unless filter = Filters.defined[@node.value[:name]]
         name = @node.value[:name]
         if ["maruku", "textile"].include?(name)
-          raise Error.new("To use the \"#{name}\" filter, please install the haml-contrib gem.", @node.line - 1)
+          raise Error.new(Error.message(:install_haml_contrib, name), @node.line - 1)
         else
-          raise Error.new("Filter \"#{name}\" is not defined.", @node.line - 1)
+          raise Error.new(Error.message(:filter_not_defined, name), @node.line - 1)
         end
       end
       filter.internal_compile(self, @node.value[:text])

data/lib/haml/error.rb

@@ -1,6 +1,45 @@
 module Haml
   # An exception raised by Haml code.
   class Error < StandardError
+
+    MESSAGES = {
+      :bad_script_indent            => '"%s" is indented at wrong level: expected %d, but was at %d.',
+      :cant_run_filter              => 'Can\'t run "%s" filter; you must require its dependencies first',
+      :cant_use_tabs_and_spaces     => "Indentation can't use both tabs and spaces.",
+      :deeper_indenting             => "The line was indented %d levels deeper than the previous line.",
+      :filter_not_defined           => 'Filter "%s" is not defined.',
+      :gem_install_filter_deps      => '"%s" filter\'s %s dependency missing: try installing it or adding it to your Gemfile',
+      :illegal_element              => "Illegal element: classes and ids must have values.",
+      :illegal_nesting_content      => "Illegal nesting: nesting within a tag that already has content is illegal.",
+      :illegal_nesting_header       => "Illegal nesting: nesting within a header command is illegal.",
+      :illegal_nesting_line         => "Illegal nesting: content can't be both given on the same line as %%%s and nested within it.",
+      :illegal_nesting_plain        => "Illegal nesting: nesting within plain text is illegal.",
+      :illegal_nesting_self_closing => "Illegal nesting: nesting within a self-closing tag is illegal.",
+      :inconsistent_indentation     => "Inconsistent indentation: %s used for indentation, but the rest of the document was indented using %s.",
+      :indenting_at_start           => "Indenting at the beginning of the document is illegal.",
+      :install_haml_contrib         => 'To use the "%s" filter, please install the haml-contrib gem.',
+      :invalid_attribute_list       => 'Invalid attribute list: %s.',
+      :invalid_filter_name          => 'Invalid filter name ":%s".',
+      :invalid_tag                  => 'Invalid tag: "%s".',
+      :missing_if                   => 'Got "%s" with no preceding "if"',
+      :no_ruby_code                 => "There's no Ruby code for %s to evaluate.",
+      :self_closing_content         => "Self-closing tags can't have content.",
+      :unbalanced_brackets          => 'Unbalanced brackets.',
+      :no_end                       => <<-END
+You don't need to use "- end" in Haml. Un-indent to close a block:
+- if foo?
+  %strong Foo!
+- else
+  Not foo.
+%p This line is un-indented, so it isn't part of the "if" block
+END
+    }
+
+    def self.message(key, *args)
+      string = MESSAGES[key] or raise "[HAML BUG] No error messages for #{key}"
+      (args.empty? ? string : string % args).rstrip
+    end
+
     # The line of the template on which the error occurred.
     #
     # @return [Fixnum]
@@ -18,5 +57,5 @@ module Haml
   # ill-formatted document.
   # It's not particularly interesting,
   # except in that it's a subclass of {Haml::Error}.
-  class SyntaxError < Haml::Error; end
+  class SyntaxError < Error; end
 end

data/lib/haml/exec.rb

@@ -1,6 +1,7 @@
 require 'optparse'
 require 'fileutils'
 require 'rbconfig'
+require 'pp'
 
 module Haml
   # This module handles the various Haml executables (`haml` and `haml-convert`).
@@ -94,7 +95,7 @@ module Haml
         end
 
         opts.on_tail("-v", "--version", "Print version") do
-          puts("Haml #{::Haml.version[:string]}")
+          puts("Haml #{::Haml::VERSION}")
           exit
         end
       end
@@ -217,7 +218,7 @@ END
         end
 
         opts.on('-f', '--format NAME',
-                'Output format. Can be xhtml (default), html4, or html5.') do |name|
+                'Output format. Can be html5 (default), xhtml, or html4.') do |name|
           @options[:for_engine][:format] = name.to_sym
         end
 
@@ -252,9 +253,14 @@ END
           end
         end
 
-        opts.on('--debug', "Print out the precompiled Ruby source.") do
+        opts.on('-d', '--debug', "Print out the precompiled Ruby source.") do
           @options[:debug] = true
         end
+
+        opts.on('-p', '--parse', "Print out Haml parse tree.") do
+          @options[:parse] = true
+        end
+
       end
 
       # Processes the options set by the command-line arguments,
@@ -272,12 +278,18 @@ END
         @options[:requires].each {|f| require f}
 
         begin
+
           engine = ::Haml::Engine.new(template, @options[:for_engine])
           if @options[:check_syntax]
             puts "Syntax OK"
             return
           end
 
+          if @options[:parse]
+            pp engine.parser.root
+            return
+          end
+
           if @options[:debug]
             puts engine.precompiled
             puts '=' * 100

data/lib/haml/filters.rb

@@ -196,19 +196,20 @@ RUBY
 
       # @see Base#render_with_options
       def render_with_options(text, options)
+        indent = options[:cdata] ? '    ' : '  ' # 4 or 2 spaces
         if options[:format] == :html5
           type = ''
         else
           type = " type=#{options[:attr_wrapper]}text/javascript#{options[:attr_wrapper]}"
         end
 
-        <<END
-<script#{type}>
-  //<![CDATA[
-    #{text.rstrip.gsub("\n", "\n    ")}
-  //]]>
-</script>
-END
+        str = "<script#{type}>\n"
+        str << "  //<![CDATA[\n" if options[:cdata]
+        str << "#{indent}#{text.rstrip.gsub("\n", "\n#{indent}")}\n"
+        str << "  //]]>\n" if options[:cdata]
+        str << "</script>"
+
+        str
       end
     end
 
@@ -219,19 +220,20 @@ END
 
       # @see Base#render_with_options
       def render_with_options(text, options)
+        indent = options[:cdata] ? '    ' : '  ' # 4 or 2 spaces
         if options[:format] == :html5
           type = ''
         else
           type = " type=#{options[:attr_wrapper]}text/css#{options[:attr_wrapper]}"
         end
 
-        <<END
-<style#{type}>
-  /*<![CDATA[*/
-    #{text.rstrip.gsub("\n", "\n    ")}
-  /*]]>*/
-</style>
-END
+        str = "<style#{type}>\n"
+        str << "  /*<![CDATA[*/\n" if options[:cdata]
+        str << "#{indent}#{text.rstrip.gsub("\n", "\n#{indent}")}\n"
+        str << "  /*]]>*/\n" if options[:cdata]
+        str << "</style>"
+
+        str
       end
     end
 
@@ -303,9 +305,10 @@ END
       def template_class
         (@template_class if defined? @template_class) or begin
           @template_class = Tilt["t.#{tilt_extension}"] or
-            raise "Can't run #{self} filter; you must require its dependencies first"
-        rescue LoadError
-          raise Error.new("Can't run #{self} filter; required dependencies not available")
+            raise Error.new(Error.message(:cant_run_filter, tilt_extension))
+        rescue LoadError => e
+          dep = e.message.split('--').last.strip
+          raise Error.new(Error.message(:gem_install_filter_deps, tilt_extension, dep))
         end
       end
 

data/lib/haml/helpers.rb

@@ -485,8 +485,8 @@ MESSAGE
       end
 
       if flags.include?(:/)
-        raise Error.new("Self-closing tags can't have content.") if text
-        raise Error.new("Illegal nesting: nesting within a self-closing tag is illegal.") if block
+        raise Error.new(Error.message(:self_closing_content)) if text
+        raise Error.new(Error.message(:illegal_nesting_self_closing)) if block
       end
 
       tag = "<#{name}#{attributes}>"
@@ -506,7 +506,7 @@ MESSAGE
       end
 
       if text
-        raise Error.new("Illegal nesting: content can't be both given to haml_tag :#{name} and nested within it.")
+        raise Error.new(Error.message(:illegal_nesting_line, name))
       end
 
       if flags.include?(:<)

data/lib/haml/options.rb

@@ -11,20 +11,21 @@ module Haml
       :escape_attrs         => true,
       :escape_html          => false,
       :filename             => '(haml)',
-      :format               => :xhtml,
+      :format               => :html5,
       :hyphenate_data_attrs => true,
       :line                 => 1,
       :mime_type            => 'text/html',
       :preserve             => %w(textarea pre code),
       :remove_whitespace    => false,
       :suppress_eval        => false,
-      :ugly                 => false
+      :ugly                 => false,
+      :cdata                => false
     }
 
-    @valid_formats = [:xhtml, :html4, :html5]
+    @valid_formats = [:html4, :html5, :xhtml]
 
     @buffer_option_keys = [:autoclose, :preserve, :attr_wrapper, :ugly, :format,
-      :encoding, :escape_html, :escape_attrs, :hyphenate_data_attrs]
+      :encoding, :escape_html, :escape_attrs, :hyphenate_data_attrs, :cdata]
 
     # The default option values.
     # @return Hash
@@ -101,11 +102,13 @@ module Haml
     # inline templates, similar to the last argument to `Kernel#eval`.
     attr_accessor :line
 
-    # Determines the output format. Normally the default is `:xhtml`, although
-    # under Rails 3 it's `:html5`, since that's the Rails 3's default format.
-    # Other options are `:html4` and `:html5`, which are identical to `:xhtml`
-    # except there are no self-closing tags, the XML prolog is ignored and
-    # correct DOCTYPEs are generated.
+    # Determines the output format. The default is `:html5`. The other options
+    # are `:html4` and `:xhtml`. If the output is set to XHTML, then Haml
+    # automatically generates self-closing tags and wraps the output of the
+    # Javascript and CSS-like filters inside CDATA. When the output is set to
+    # :html5 or :html4, XML prologs are ignored. In all cases, an appropriate
+    # doctype is generated from '!!!'.
+    #
     #
     # If the mime_type of the template being rendered is `text/xml` then a
     # format of `:xhtml` will be used even if the global output format is set to
@@ -147,6 +150,16 @@ module Haml
     # Defaults to `true` in Rails production  mode, and `false` everywhere else.
     attr_accessor :ugly
 
+    # Whether to include CDATA sections around javascript and css blocks when
+    # using the `:javascript` or `:css` filters.
+    #
+    # This option also affects the `:sass`, `:scss`, `:less` and `:coffeescript`
+    # filters.
+    #
+    # Defaults to `false` for html, `true` for xhtml. Cannot be changed when using
+    # xhtml.
+    attr_accessor :cdata
+
     def initialize(values = {}, &block)
       defaults.each {|k, v| instance_variable_set :"@#{k}", v}
       values.reject {|k, v| !defaults.has_key?(k) || v.nil?}.each {|k, v| send("#{k}=", v)}
@@ -203,7 +216,7 @@ module Haml
     # macro in order to make it appear in Yard's list of instance attributes.
     undef :format
     def format
-      mime_type == "text/xml" ? "xhtml" : @format
+      mime_type == "text/xml" ? :xhtml : @format
     end
 
     def format=(value)
@@ -213,6 +226,11 @@ module Haml
       @format = value
     end
 
+    undef :cdata
+    def cdata
+      xhtml? || @cdata
+    end
+
     def remove_whitespace=(value)
       @ugly = true if value
       @remove_whitespace = value

data/lib/haml/parser.rb

@@ -4,6 +4,8 @@ module Haml
   class Parser
     include Haml::Util
 
+    attr_reader :root
+
     # Designates an XHTML/XML element.
     ELEMENT         = ?%
 
@@ -63,8 +65,16 @@ module Haml
     # of a multiline string.
     MULTILINE_CHAR_VALUE = ?|
 
+    # Regex to check for blocks with spaces around arguments. Not to be confused
+    # with multiline script.
+    # For example:
+    #     foo.each do | bar |
+    #       = bar
+    #
+    BLOCK_WITH_SPACES = /do[\s]*\|[\s]*[^\|]*[\s]+\|\z/
+
     MID_BLOCK_KEYWORDS = %w[else elsif rescue ensure end when]
-    START_BLOCK_KEYWORDS = %w[if begin case]
+    START_BLOCK_KEYWORDS = %w[if begin case unless]
     # Try to parse assignments to block starters as best as possible
     START_BLOCK_KEYWORD_REGEX = /(?:\w+(?:,\s*\w+)*\s*=\s*)?(#{START_BLOCK_KEYWORDS.join('|')})/
     BLOCK_KEYWORD_REGEX = /^-\s*(?:(#{MID_BLOCK_KEYWORDS.join('|')})|#{START_BLOCK_KEYWORD_REGEX.source})\b/
@@ -75,14 +85,18 @@ module Haml
     # The Regex that matches a literal string or symbol value
     LITERAL_VALUE_REGEX = /:(\w*)|(["'])((?![\\#]|\2).|\\.)*\2/
 
+
     def initialize(template, options)
       # :eod is a special end-of-document marker
-      @template       = (template.rstrip).split(/\r\n|\r|\n/) + [:eod, :eod]
-      @options        = options
-      @flat           = false
-      @index          = 0
-      @template_index = 0
-      @template_tabs  = 0
+      @template           = (template.rstrip).split(/\r\n|\r|\n/) + [:eod, :eod]
+      @options            = options
+      @flat               = false
+      @index              = 0
+      # Record the indent levels of "if" statements to validate the subsequent
+      # elsif and else statements are indented at the appropriate level.
+      @script_level_stack = []
+      @template_index     = 0
+      @template_tabs      = 0
     end
 
     def parse
@@ -91,7 +105,7 @@ module Haml
       @indentation = nil
       @line = next_line
 
-      raise SyntaxError.new("Indenting at the beginning of the document is illegal.", @line.index) if @line.tabs != 0
+      raise SyntaxError.new(Error.message(:indenting_at_start), @line.index) if @line.tabs != 0
 
       while next_line
         process_indent(@line) unless @line.text.empty?
@@ -112,7 +126,7 @@ module Haml
         end
 
         if !@haml_comment && !flat? && @next_line.tabs - @line.tabs > 1
-          raise SyntaxError.new("The line was indented #{@next_line.tabs - @line.tabs} levels deeper than the previous line.", @next_line.index)
+          raise SyntaxError.new(Error.message(:deeper_indenting, @next_line.tabs - @line.tabs), @next_line.index)
         end
 
         @line = @next_line
@@ -143,7 +157,7 @@ module Haml
             @indentation = whitespace
 
             if @indentation.include?(?\s) && @indentation.include?(?\t)
-              raise SyntaxError.new("Indentation can't use both tabs and spaces.", line.index)
+              raise SyntaxError.new(Error.message(:cant_use_tabs_and_spaces), line.index)
             end
 
             @flat_spaces = @indentation * (@template_tabs+1) if flat?
@@ -154,10 +168,11 @@ module Haml
           break tabs if whitespace == @indentation * tabs
           break @template_tabs + 1 if flat? && whitespace =~ /^#{@flat_spaces}/
 
-          raise SyntaxError.new(<<END.strip.gsub("\n", ' '), line.index)
-Inconsistent indentation: #{Haml::Util.human_indentation whitespace, true} used for indentation,
-but the rest of the document was indented using #{Haml::Util.human_indentation @indentation}.
-END
+          message = Error.message(:inconsistent_indentation,
+            Haml::Util.human_indentation(whitespace),
+            Haml::Util.human_indentation(@indentation)
+          )
+          raise SyntaxError.new(message, line.index)
         end
       end
     end
@@ -238,7 +253,7 @@ END
 
     def plain(text, escape_html = nil)
       if block_opened?
-        raise SyntaxError.new("Illegal nesting: nesting within plain text is illegal.", @next_line.index)
+        raise SyntaxError.new(Error.message(:illegal_nesting_plain), @next_line.index)
       end
 
       unless contains_interpolation?(text)
@@ -250,7 +265,7 @@ END
     end
 
     def script(text, escape_html = nil, preserve = false)
-      raise SyntaxError.new("There's no Ruby code for = to evaluate.") if text.empty?
+      raise SyntaxError.new(Error.message(:no_ruby_code, '=')) if text.empty?
       text = handle_ruby_multiline(text)
       escape_html = @options[:escape_html] if escape_html.nil?
 
@@ -259,26 +274,32 @@ END
     end
 
     def flat_script(text, escape_html = nil)
-      raise SyntaxError.new("There's no Ruby code for ~ to evaluate.") if text.empty?
+      raise SyntaxError.new(Error.message(:no_ruby_code, '~')) if text.empty?
       script(text, escape_html, :preserve)
     end
 
     def silent_script(text)
       return haml_comment(text[2..-1]) if text[1] == SILENT_COMMENT
 
-      raise SyntaxError.new(<<END.rstrip, @index - 1) if text[1..-1].strip == "end"
-You don't need to use "- end" in Haml. Un-indent to close a block:
-- if foo?
-  %strong Foo!
-- else
-  Not foo.
-%p This line is un-indented, so it isn't part of the "if" block
-END
+      raise SyntaxError.new(Error.message(:no_end), @index - 1) if text[1..-1].strip == "end"
 
       text = handle_ruby_multiline(text)
       keyword = block_keyword(text)
 
-      @tab_up = ["if", "case"].include?(keyword)
+      if ["if", "case", "unless"].include?(keyword)
+        @script_level_stack.push(@line.tabs)
+        @tab_up = true
+      end
+
+      if ["else", "elsif"].include?(keyword)
+        if @script_level_stack.empty?
+          raise Haml::SyntaxError.new(Error.message(:missing_if, keyword), @line.index)
+        elsif @script_level_stack.last != @line.tabs
+          message = Error.message(:bad_script_indent, keyword, @script_level_stack.last, @line.tabs)
+          raise Haml::SyntaxError.new(message, @line.index)
+        end
+      end
+
       ParseNode.new(:silent_script, @index,
         :text => text[1..-1], :keyword => keyword)
     end
@@ -346,12 +367,12 @@ END
 
       attributes_list.compact!
 
-      raise SyntaxError.new("Illegal nesting: nesting within a self-closing tag is illegal.", @next_line.index) if block_opened? && self_closing
-      raise SyntaxError.new("There's no Ruby code for #{action} to evaluate.", last_line - 1) if parse && value.empty?
-      raise SyntaxError.new("Self-closing tags can't have content.", last_line - 1) if self_closing && !value.empty?
+      raise SyntaxError.new(Error.message(:illegal_nesting_self_closing), @next_line.index) if block_opened? && self_closing
+      raise SyntaxError.new(Error.message(:no_ruby_code, action), last_line - 1) if parse && value.empty?
+      raise SyntaxError.new(Error.message(:self_closing_content), last_line - 1) if self_closing && !value.empty?
 
       if block_opened? && !value.empty? && !is_ruby_multiline?(value)
-        raise SyntaxError.new("Illegal nesting: content can't be both given on the same line as %#{tag_name} and nested within it.", @next_line.index)
+        raise SyntaxError.new(Error.message(:illegal_nesting_line, tag_name), @next_line.index)
       end
 
       self_closing ||= !!(!block_opened? && value.empty? && @options[:autoclose].any? {|t| t === tag_name})
@@ -379,7 +400,7 @@ END
       conditional << ">" if conditional
 
       if block_opened? && !line.empty?
-        raise SyntaxError.new('Illegal nesting: nesting within a tag that already has content is illegal.', @next_line.index)
+        raise SyntaxError.new(Haml::Error.message(:illegal_nesting_content), @next_line.index)
       end
 
       ParseNode.new(:comment, @index, :conditional => conditional, :text => line)
@@ -387,13 +408,13 @@ END
 
     # Renders an XHTML doctype or XML shebang.
     def doctype(line)
-      raise SyntaxError.new("Illegal nesting: nesting within a header command is illegal.", @next_line.index) if block_opened?
+      raise SyntaxError.new(Error.message(:illegal_nesting_header), @next_line.index) if block_opened?
       version, type, encoding = line[3..-1].strip.downcase.scan(DOCTYPE_REGEX)[0]
       ParseNode.new(:doctype, @index, :version => version, :type => type, :encoding => encoding)
     end
 
     def filter(name)
-      raise Error.new("Invalid filter name \":#{name}\".") unless name =~ /^\w+$/
+      raise Error.new(Error.message(:invalid_filter_name, name)) unless name =~ /^\w+$/
 
       @filter_buffer = String.new
 
@@ -423,6 +444,8 @@ END
     end
 
     def close_silent_script(node)
+      @script_level_stack.pop if node.value[:keyword] == "if"
+
       # Post-process case statements to normalize the nesting of "when" clauses
       return unless node.value[:keyword] == "case"
       return unless first = node.children.first
@@ -473,10 +496,14 @@ END
 
     # Parses a line into tag_name, attributes, attributes_hash, object_ref, action, value
     def parse_tag(line)
-      raise SyntaxError.new("Invalid tag: \"#{line}\".") unless match = line.scan(/%([-:\w]+)([-:\w\.\#]*)(.*)/)[0]
+      match = line.scan(/%([-:\w]+)([-:\w\.\#]*)(.*)/)[0]
+      raise SyntaxError.new(Error.message(:invalid_tag, line)) unless match
 
       tag_name, attributes, rest = match
-      raise SyntaxError.new("Illegal element: classes and ids must have values.") if attributes =~ /[\.#](\.|#|\z)/
+
+      if attributes =~ /[\.#](\.|#|\z)/
+        raise SyntaxError.new(Error.message(:illegal_element))
+      end
 
       new_attributes_hash = old_attributes_hash = last_line = nil
       object_ref = "nil"
@@ -522,7 +549,7 @@ END
       begin
         attributes_hash, rest = balance(line, ?{, ?})
       rescue SyntaxError => e
-        if line.strip[-1] == ?, && e.message == "Unbalanced brackets."
+        if line.strip[-1] == ?, && e.message == Error.message(:unbalanced_brackets)
           line << "\n" << @next_line.text
           last_line += 1
           next_line
@@ -549,7 +576,7 @@ END
 
         if name == false
           text = (Haml::Util.balance(line, ?(, ?)) || [line]).first
-          raise Haml::SyntaxError.new("Invalid attribute list: #{text.inspect}.", last_line - 1)
+          raise Haml::SyntaxError.new(Error.message(:invalid_attribute_list, text.inspect), last_line - 1)
         end
         attributes[name] = value
         scanner.scan(/\s*/)
@@ -666,7 +693,7 @@ END
 
     # Checks whether or not `line` is in a multiline sequence.
     def is_multiline?(text)
-      text && text.length > 1 && text[-1] == MULTILINE_CHAR_VALUE && text[-2] == ?\s
+      text && text.length > 1 && text[-1] == MULTILINE_CHAR_VALUE && text[-2] == ?\s && text !~ BLOCK_WITH_SPACES
     end
 
     def handle_ruby_multiline(text)
@@ -697,7 +724,7 @@ END
     def balance(*args)
       res = Haml::Util.balance(*args)
       return res if res
-      raise SyntaxError.new("Unbalanced brackets.")
+      raise SyntaxError.new(Error.message(:unbalanced_brackets))
     end
 
     def block_opened?