haml 1.8.2 → 2.0.0

data/lib/haml/helpers.rb

@@ -34,25 +34,44 @@ module Haml
     #     include Haml::Helpers
     #   end
     #   context.init_haml_helpers
-    #   context.open :p, "Stuff"
-    # 
+    #   context.haml_tag :p, "Stuff"
+    #
     def init_haml_helpers
-      @haml_is_haml = true
-      @haml_stack = [Haml::Buffer.new]
+      @haml_buffer = Haml::Buffer.new(@haml_buffer, Haml::Engine.new('').send(:options_for_buffer))
       nil
     end
 
     # call-seq:
-    #   find_and_preserve(input)
+    #   non_haml { ... }
+    #
+    # Runs a block of code in a non-Haml context
+    # (i.e. #is_haml? will return false).
+    #
+    # This is mainly useful for rendering sub-templates such as partials in a non-Haml language,
+    # particularly where helpers may behave differently when run from Haml.
+    #
+    # Note that this is automatically applied to Rails partials.
+    def non_haml
+      was_active = @haml_buffer.active?
+      @haml_buffer.active = false
+      res = yield
+      @haml_buffer.active = was_active
+      res
+    end
+
+    # call-seq:
+    #   find_and_preserve(input, tags = haml_buffer.options[:preserve])
     #   find_and_preserve {...}
-    #   
-    # Isolates the whitespace-sensitive tags in the string and uses preserve
-    # to convert any endlines inside them into HTML entities for endlines.
-    def find_and_preserve(input = '', &block)
+    #
+    # Uses preserve to convert any newlines inside whitespace-sensitive tags
+    # into the HTML entities for endlines.
+    # @tags@ is an array of tags to preserve.
+    # It defaults to the value of the <tt>:preserve</tt> option.
+    def find_and_preserve(input = '', tags = haml_buffer.options[:preserve], &block)
       return find_and_preserve(capture_haml(&block)) if block
 
       input = input.to_s
-      input.gsub(/<(textarea|code|pre)([^>]*)>(.*?)(<\/\1>)/im) do
+      input.gsub(/<(#{tags.map(&Regexp.method(:escape)).join('|')})([^>]*)>(.*?)(<\/\1>)/im) do
         "<#{$1}#{$2}>#{preserve($3)}</#{$1}>"
       end
     end
@@ -67,7 +86,7 @@ module Haml
     def preserve(input = '', &block)
       return preserve(capture_haml(&block)) if block
 
-      input.gsub(/\n/, '&#x000A;').gsub(/\r/, '')
+      input.chomp("\n").gsub(/\n/, '&#x000A;').gsub(/\r/, '')
     end
 
     alias_method :flatten, :preserve
@@ -107,14 +126,14 @@ module Haml
     def list_of(array, &block) # :yields: item
       to_return = array.collect do |i|
         result = capture_haml(i, &block)
-        
+
         if result.count("\n") > 1
           result.gsub!("\n", "\n  ")
           result = "\n  #{result.strip}\n"
         else
           result.strip!
         end
-        
+
         "<li>#{result}</li>"
       end
       to_return.join("\n")
@@ -156,14 +175,14 @@ module Haml
       haml_buffer.tabulation += i
     end
 
-    # Increments the number of tabs the buffer automatically adds
+    # Decrements the number of tabs the buffer automatically adds
     # to the lines of the template.
     #
-    # See tab_up.
+    # See also tab_up.
     def tab_down(i = 1)
       haml_buffer.tabulation -= i
     end
-    
+
     # Surrounds the given block of Haml code with the given characters,
     # with no whitespace in between.
     # For example:
@@ -187,10 +206,10 @@ module Haml
     def surround(front, back = nil, &block)
       back ||= front
       output = capture_haml(&block)
-      
+
       "#{front}#{output.chomp}#{back}\n"
     end
-    
+
     # Prepends the given character to the beginning of the Haml block,
     # with no whitespace between.
     # For example:
@@ -205,7 +224,7 @@ module Haml
     def precede(char, &block)
       "#{char}#{capture_haml(&block).chomp}\n"
     end
-    
+
     # Appends the given character to the end of the Haml block,
     # with no whitespace between.
     # For example:
@@ -222,7 +241,7 @@ module Haml
     def succeed(char, &block)
       "#{capture_haml(&block).chomp}#{char}\n"
     end
-    
+
     # Captures the result of the given block of Haml code,
     # gets rid of the excess indentation,
     # and returns it as a string.
@@ -246,24 +265,24 @@ module Haml
 
     #
     # call-seq:
-    #   open(name, attributes = {}) {...}
-    #   open(name, text, attributes = {}) {...}
+    #   haml_tag(name, attributes = {}) {...}
+    #   haml_tag(name, text, attributes = {}) {...}
     #
     # Creates an HTML tag with the given name and optionally text and attributes.
     # Can take a block that will be executed
     # between when the opening and closing tags are output.
     # If the block is a Haml block or outputs text using puts,
     # the text will be properly indented.
-    # 
+    #
     # For example,
     #
-    #   open :table do
-    #     open :tr do
-    #       open :td, {:class => 'cell'} do
-    #         open :strong, "strong!"
+    #   haml_tag :table do
+    #     haml_tag :tr do
+    #       haml_tag :td, {:class => 'cell'} do
+    #         haml_tag :strong, "strong!"
     #         puts "data"
     #       end
-    #       open :td do
+    #       haml_tag :td do
     #         puts "more_data"
     #       end
     #     end
@@ -286,18 +305,23 @@ module Haml
     #   </table>
     #
     def haml_tag(name, attributes = {}, alt_atts = {}, &block)
+      name = name.to_s
+
       text = nil
       if attributes.is_a? String
         text = attributes
         attributes = alt_atts
       end
 
-      if text.nil? && block.nil?
-        puts "<#{name}#{Haml::Precompiler.build_attributes(haml_buffer.options[:attr_wrapper], attributes)} />"
+      attributes = Haml::Precompiler.build_attributes(
+        haml_buffer.html?, haml_buffer.options[:attr_wrapper], attributes)
+
+      if text.nil? && block.nil? && haml_buffer.options[:autoclose].include?(name)
+        puts "<#{name}#{attributes} />"
         return nil
       end
 
-      puts "<#{name}#{Haml::Precompiler.build_attributes(haml_buffer.options[:attr_wrapper], attributes)}>"
+      puts "<#{name}#{attributes}>"
       unless text && text.empty?
         tab_up
         # Print out either the text (using push_text) or call the block and add an endline
@@ -312,22 +336,37 @@ module Haml
       nil
     end
 
-    def open(*args, &block)
-              warn <<END
-DEPRECATION WARNING:
-The Haml #open helper is deprecated and will be removed in version 2.0.
-Use the #haml_tag method instead.
-END
-      haml_tag(*args, &block)
+    # Characters that need to be escaped to HTML entities from user input
+    HTML_ESCAPE = { '&'=>'&amp;', '<'=>'&lt;', '>'=>'&gt;', '"'=>'&quot;', "'"=>'&#039;', }
+
+    # Returns a copy of <tt>text</tt> with ampersands, angle brackets and quotes
+    # escaped into HTML entities.
+    def html_escape(text)
+      text.to_s.gsub(/[\"><&]/) { |s| HTML_ESCAPE[s] }
+    end
+
+    # Escapes HTML entities in <tt>text</tt>, but without escaping an ampersand
+    # that is already part of an escaped entity.
+    def escape_once(text)
+      text.to_s.gsub(/[\"><]|&(?!([a-zA-Z]+|(#\d+));)/) { |s| HTML_ESCAPE[s] }
     end
-    
+
+    # Returns whether or not the current template is a Haml template.
+    #
+    # This function, unlike other Haml::Helpers functions,
+    # also works in other ActionView templates,
+    # where it will always return false.
+    def is_haml?
+      !@haml_buffer.nil? && @haml_buffer.active?
+    end
+
     private
 
     # Gets a reference to the current Haml::Buffer object.
     def haml_buffer
-      @haml_stack[-1]
+      @haml_buffer
     end
-    
+
     # Gives a proc the same local "_hamlout" and "_erbout" variables
     # that the current template has.
     def haml_bind_proc(&proc)
@@ -335,46 +374,42 @@ END
       _erbout = _hamlout.buffer
       proc { |*args| proc.call(*args) }
     end
-    
+
     # Performs the function of capture_haml, assuming <tt>local_buffer</tt>
     # is where the output of block goes.
     def capture_haml_with_buffer(local_buffer, *args, &block)
       position = local_buffer.length
-      
+
       block.call *args
-      
+
       captured = local_buffer.slice!(position..-1)
-      
+
       min_tabs = nil
       captured.each do |line|
         tabs = line.index(/[^ ]/)
         min_tabs ||= tabs
         min_tabs = min_tabs > tabs ? tabs : min_tabs
       end
-      
+
       result = captured.map do |line|
         line[min_tabs..-1]
       end
       result.to_s
     end
 
-    # Returns whether or not the current template is a Haml template.
-    # 
-    # This function, unlike other Haml::Helpers functions,
-    # also works in other ActionView templates,
-    # where it will always return false.
-    def is_haml?
-      @haml_is_haml
-    end
-
     include ActionViewExtensions if self.const_defined? "ActionViewExtensions"
   end
 end
 
-module ActionView
-  class Base # :nodoc:
-    def is_haml?
-      false
-    end
+class Object
+  # Haml overrides various ActionView helpers,
+  # which call an #is_haml? method
+  # to determine whether or not the current context object
+  # is a proper Haml context.
+  # Because ActionView helpers may be included in non-ActionView::Base classes,
+  # it's a good idea to define is_haml? for all objects.
+  def is_haml?
+    false
   end
 end
+

data/lib/haml/helpers/action_view_extensions.rb

@@ -31,7 +31,7 @@ if defined?(ActionView)
         #
         #   .entry
         #     :color #00f
-        # 
+        #
         def page_class
           controller.controller_name + " " + controller.action_name
         end

data/lib/haml/helpers/action_view_mods.rb

@@ -2,11 +2,8 @@ if defined?(ActionView) and not defined?(Merb::Plugins)
   module ActionView
     class Base # :nodoc:
       def render_with_haml(*args, &block)
-        was_haml = is_haml?
-        @haml_is_haml = false
-        res = render_without_haml(*args, &block)
-        @haml_is_haml = was_haml
-        res
+        return non_haml { render_without_haml(*args, &block) } if is_haml?
+        render_without_haml(*args, &block)
       end
       alias_method :render_without_haml, :render
       alias_method :render, :render_with_haml
@@ -17,6 +14,28 @@ if defined?(ActionView) and not defined?(Merb::Plugins)
     module Helpers
       # :stopdoc:
       module CaptureHelper
+        def capture_with_haml(*args, &block)
+          # Rails' #capture helper will just return the value of the block
+          # if it's not actually in the template context,
+          # as detected by the existance of an _erbout variable.
+          # We've got to do the same thing for compatibility.
+          block_is_haml =
+            begin
+              eval('_hamlout', block)
+              true
+            rescue
+              false
+            end
+
+          if block_is_haml && is_haml?
+            capture_haml(*args, &block)
+          else
+            capture_without_haml(*args, &block)
+          end
+        end
+        alias_method :capture_without_haml, :capture
+        alias_method :capture, :capture_with_haml
+
         def capture_erb_with_buffer_with_haml(*args, &block)
           if is_haml?
             capture_haml_with_buffer(*args, &block)
@@ -40,6 +59,35 @@ if defined?(ActionView) and not defined?(Merb::Plugins)
         alias_method :concat, :concat_with_haml
       end
 
+      module TagHelper
+        def content_tag_with_haml(name, *args, &block)
+          content = content_tag_without_haml(name, *args, &block)
+
+          if is_haml? && haml_buffer.options[:preserve].include?(name.to_s)
+            content = Haml::Helpers.preserve content
+          end
+
+          content
+        end
+        alias_method :content_tag_without_haml, :content_tag
+        alias_method :content_tag, :content_tag_with_haml
+      end
+
+      class InstanceTag
+        # Includes TagHelper
+
+        def haml_buffer
+          @template_object.send :haml_buffer
+        end
+
+        def is_haml?
+          @template_object.send :is_haml?
+        end
+
+        alias_method :content_tag_without_haml, :content_tag
+        alias_method :content_tag, :content_tag_with_haml
+      end
+
       module FormTagHelper
         def form_tag_with_haml(url_for_options = {}, options = {}, *parameters_for_url, &proc)
           if is_haml?
@@ -66,7 +114,7 @@ if defined?(ActionView) and not defined?(Merb::Plugins)
       module FormHelper
         def form_for_with_haml(object_name, *args, &proc)
           if block_given? && is_haml?
-            oldproc = proc 
+            oldproc = proc
             proc = haml_bind_proc do |*args|
               tab_up
               oldproc.call(*args)

data/lib/haml/html.rb

@@ -59,7 +59,7 @@ module Haml
           String.new
         else
           lines = text.split("\n")
-          
+
           lines.map do |line|
             line.strip!
             "#{tabulate(tabs)}#{'\\' if Haml::Engine::SPECIAL_CHARACTERS.include?(line[0])}#{line}\n"
@@ -73,7 +73,7 @@ module Haml
     def self.options
       @@options
     end
-    
+
     TEXT_REGEXP = /^(\s*).*$/
 
     class ::Hpricot::Doc
@@ -129,14 +129,14 @@ module Haml
 
     class ::Hpricot::Elem
       def to_haml(tabs = 0)
-        output = "#{tabulate(tabs)}"        
+        output = "#{tabulate(tabs)}"
         if HTML.options[:rhtml] && name[0...5] == 'haml:'
           return output + HTML.send("haml_tag_#{name[5..-1]}",
                                     CGI.unescapeHTML(self.innerHTML))
         end
 
         output += "%#{name}" unless name == 'div' && (attributes.include?('id') || attributes.include?('class'))
-        
+
         if attributes
           output += "##{attributes['id']}" if attributes['id']
           attributes['class'].split(' ').each { |c| output += ".#{c}" } if attributes['class']
@@ -144,10 +144,10 @@ module Haml
           remove_attribute('class')
           output += haml_attributes if attributes.length > 0
         end
-        
+
         output += "/" if children.length == 0
         output += "\n"
-        
+
         self.children.each do |child|
           output += child.to_haml(tabs + 1)
         end

data/lib/haml/precompiler.rb

@@ -14,12 +14,15 @@ module Haml
     # Designates an XHTML/XML comment.
     COMMENT         = ?/
 
-    # Designates an XHTML doctype.
+    # Designates an XHTML doctype or script that is never HTML-escaped.
     DOCTYPE         = ?!
 
     # Designates script, the result of which is output.
     SCRIPT          = ?=
 
+    # Designates script that is always HTML-escaped.
+    SANITIZE        = ?&
+
     # Designates script, the result of which is flattened and output.
     FLAT_SCRIPT     = ?~
 
@@ -47,6 +50,7 @@ module Haml
       COMMENT,
       DOCTYPE,
       SCRIPT,
+      SANITIZE,
       FLAT_SCRIPT,
       SILENT_SCRIPT,
       ESCAPE,
@@ -75,15 +79,9 @@ module Haml
     # is a member of this array.
     MID_BLOCK_KEYWORDS   = ['else', 'elsif', 'rescue', 'ensure', 'when']
 
-    # The Regex that matches an HTML comment command.
-    COMMENT_REGEX = /\/(\[[\w\s\.]*\])?(.*)/
-
     # The Regex that matches a Doctype command.
     DOCTYPE_REGEX = /(\d\.\d)?[\s]*([a-z]*)/i
 
-    # The Regex that matches an HTML tag command.
-    TAG_REGEX = /[%]([-:\w]+)([-\w\.\#]*)(\{.*\})?(\[.*\])?([=\/\~]?)?(.*)?/
-
     # The Regex that matches a literal string or symbol value
     LITERAL_VALUE_REGEX = /^\s*(:(\w*)|(('|")([^\\\#'"]*?)\4))\s*$/
 
@@ -93,15 +91,12 @@ module Haml
     def precompiled_with_ambles(local_names)
       preamble = <<END.gsub("\n", ";")
 extend Haml::Helpers
-@haml_stack ||= Array.new
-@haml_stack.push(Haml::Buffer.new(#{options_for_buffer.inspect}))
-@haml_is_haml = true
-_hamlout = @haml_stack[-1]
+_hamlout = @haml_buffer = Haml::Buffer.new(@haml_buffer, #{options_for_buffer.inspect})
 _erbout = _hamlout.buffer
 END
       postamble = <<END.gsub("\n", ";")
-@haml_is_haml = false
-@haml_stack.pop.buffer
+@haml_buffer = @haml_buffer.upper
+_erbout
 END
       preamble + locals_code(local_names) + @precompiled + postamble
     end
@@ -122,12 +117,12 @@ END
       @tab_change  = 0
 
       old_line = Line.new
-      (@template + "\n-#\n-#").split(/\n?\r|\r?\n/).each_with_index do |text, index|
+      (@template + "\n-#\n-#").split(/\r\n|\r|\n/).each_with_index do |text, index|
         line = Line.new text.strip, text.lstrip.chomp, index
         line.spaces, line.tabs = count_soft_tabs(text)
 
         if line.text.empty?
-          process_indent(old_line) unless !flat? || old_line.text.empty?
+          process_indent(old_line) if flat? && !old_line.text.empty?
 
           unless flat?
             newline
@@ -144,6 +139,7 @@ END
 
         if old_line.text.nil? || suppress_render
           old_line = line
+          resolve_newlines
           newline
           next
         end
@@ -158,15 +154,20 @@ END
         end
 
         if old_line.spaces != old_line.tabs * 2
-          raise SyntaxError.new("Illegal Indentation: Only two space characters are allowed as tabulation.")
+          raise SyntaxError.new(<<END.strip, 1 + old_line.index - @index)
+#{old_line.spaces} space#{old_line.spaces == 1 ? ' was' : 's were'} used for indentation. Haml must be indented using two spaces.
+END
         end
 
         unless old_line.text.empty? || @haml_comment
           process_line(old_line.text, old_line.index, line.tabs > old_line.tabs && !line.text.empty?)
         end
+        resolve_newlines
 
         if !flat? && line.tabs - old_line.tabs > 1
-          raise SyntaxError.new("Illegal Indentation: Indenting more than once per line is illegal.")
+          raise SyntaxError.new(<<END.strip, 2 + old_line.index - @index)
+#{line.spaces} spaces were used for indentation. Haml must be indented using two spaces.
+END
         end
         old_line = line
         newline
@@ -176,7 +177,7 @@ END
       close until @to_close_stack.empty?
       flush_merged_text
     end
-        
+
     # Processes and deals with lowering indentation.
     def process_indent(line)
       return unless line.tabs <= @template_tabs && @template_tabs > 0
@@ -196,28 +197,35 @@ END
       case text[0]
       when DIV_CLASS, DIV_ID; render_div(text)
       when ELEMENT; render_tag(text)
-      when COMMENT; render_comment(text)
+      when COMMENT; render_comment(text[1..-1].strip)
+      when SANITIZE
+        return push_script(unescape_interpolation(text[3..-1].strip), false, false, false, true) if text[1..2] == "=="
+        return push_script(text[2..-1].strip, false, false, false, true) if text[1] == SCRIPT
+        push_plain text
       when SCRIPT
         return push_script(unescape_interpolation(text[2..-1].strip), false) if text[1] == SCRIPT
+        return push_script(text[1..-1], false, false, false, true) if options[:escape_html]
         push_script(text[1..-1], false)
       when FLAT_SCRIPT; push_flat_script(text[1..-1])
       when SILENT_SCRIPT
         return start_haml_comment if text[1] == SILENT_COMMENT
 
         push_silent(text[1..-1], true)
-        newline true
+        newline_now
         if (@block_opened && !mid_block_keyword?(text)) || text[1..-1].split(' ', 2)[0] == "case"
           push_and_tabulate([:script])
         end
       when FILTER; start_filtered(text[1..-1].downcase)
       when DOCTYPE
         return render_doctype(text) if text[0...3] == '!!!'
+        return push_script(unescape_interpolation(text[3..-1].strip), false) if text[1..2] == "=="
+        return push_script(text[2..-1].strip, false) if text[1] == SCRIPT
         push_plain text
       when ESCAPE; push_plain text[1..-1]
       else push_plain text
       end
     end
-    
+
     # Returns whether or not the text is a silent script text with one
     # of Ruby's mid-block keywords.
     def mid_block_keyword?(text)
@@ -237,7 +245,7 @@ END
         @multiline.text << text[0...-1]
         return true
       end
-      
+
       # A multiline string has just been activated, start adding the lines
       if is_multiline?(text) && (MULTILINE_STARTERS.include? text[0])
         @multiline = Line.new text[0...-1], nil, line.index, nil, line.tabs
@@ -262,73 +270,91 @@ END
     # Evaluates <tt>text</tt> in the context of the scope object, but
     # does not output the result.
     def push_silent(text, can_suppress = false)
-      flush_merged_text      
+      flush_merged_text
       return if can_suppress && options[:suppress_eval]
       @precompiled << "#{text};"
     end
 
     # Adds <tt>text</tt> to <tt>@buffer</tt> with appropriate tabulation
     # without parsing it.
-    def push_merged_text(text, tab_change = 0, try_one_liner = false)
-      @merged_text  << "#{'  ' * @output_tabs}#{text}"
+    def push_merged_text(text, tab_change = 0, indent = true)
+      @merged_text  << (!indent || @dont_indent_next_line || @options[:ugly] ? text : "#{'  ' * @output_tabs}#{text}")
+      @dont_indent_next_line = false
       @tab_change   += tab_change
-      @try_one_liner = try_one_liner
     end
-    
-    def push_text(text, tab_change = 0, try_one_liner = false)
-      push_merged_text("#{text}\n", tab_change, try_one_liner)
+
+    # Concatenate <tt>text</tt> to <tt>@buffer</tt> without tabulation.
+    def concat_merged_text(text)
+      @merged_text  << text
     end
-    
+
+    def push_text(text, tab_change = 0)
+      push_merged_text("#{text}\n", tab_change)
+    end
+
     def flush_merged_text
       return if @merged_text.empty?
 
       @precompiled  << "_hamlout.push_text(#{@merged_text.dump}"
-      @precompiled  << ", #{@tab_change}" if @tab_change != 0 || @try_one_liner
+      @precompiled  << ", #{@dont_tab_up_next_text.inspect}" if @dont_tab_up_next_text || @tab_change != 0
+      @precompiled  << ", #{@tab_change}" if @tab_change != 0
       @precompiled  << ");"
       @merged_text   = ''
+      @dont_tab_up_next_text = false
       @tab_change    = 0
-      @try_one_liner = false
-    end  
+    end
 
     # Renders a block of text as plain text.
     # Also checks for an illegally opened block.
     def push_plain(text)
-      raise SyntaxError.new("Illegal Nesting: Nesting within plain text is illegal.") if @block_opened
+      raise SyntaxError.new("Illegal nesting: nesting within plain text is illegal.", 1) if @block_opened
       push_text text
     end
 
     # Adds +text+ to <tt>@buffer</tt> while flattening text.
     def push_flat(line)
-      tabulation = line.spaces - @flat_spaces
-      tabulation = tabulation > -1 ? tabulation : 0
-      @filter_buffer << "#{' ' * tabulation}#{line.unstripped}\n"
+      unless @options[:ugly]
+        tabulation = line.spaces - @flat_spaces
+        tabulation = tabulation > -1 ? tabulation : 0
+        @filter_buffer << "#{' ' * tabulation}#{line.unstripped}\n"
+      else
+        @filter_buffer << "#{line.unstripped}\n"
+      end
     end
 
     # Causes <tt>text</tt> to be evaluated in the context of
     # the scope object and the result to be added to <tt>@buffer</tt>.
     #
-    # If <tt>flattened</tt> is true, Haml::Helpers#find_and_flatten is run on
+    # If <tt>preserve_script</tt> is true, Haml::Helpers#find_and_flatten is run on
     # the result before it is added to <tt>@buffer</tt>
-    def push_script(text, flattened, close_tag = nil)
+    def push_script(text, preserve_script, in_tag = false, preserve_tag = false,
+                    escape_html = false, nuke_inner_whitespace = false)
+      # Prerender tabulation unless we're in a tag
+      push_merged_text '' unless in_tag
+
       flush_merged_text
       return if options[:suppress_eval]
 
+      raise SyntaxError.new("There's no Ruby code for = to evaluate.") if text.empty?
+
       push_silent "haml_temp = #{text}"
-      newline true
-      out = "haml_temp = _hamlout.push_script(haml_temp, #{flattened.inspect}, #{close_tag.inspect});"
+      newline_now
+      args = [preserve_script, in_tag, preserve_tag,
+              escape_html, nuke_inner_whitespace].map { |a| a.inspect }.join(', ')
+      out = "haml_temp = _hamlout.push_script(haml_temp, #{args});"
       if @block_opened
         push_and_tabulate([:loud, out])
       else
         @precompiled << out
       end
     end
-    
+
     # Causes <tt>text</tt> to be evaluated, and Haml::Helpers#find_and_flatten
     # to be run on it afterwards.
     def push_flat_script(text)
       flush_merged_text
-      
-      raise SyntaxError.new("Tag has no content.") if text.empty?
+
+      raise SyntaxError.new("There's no Ruby code for ~ to evaluate.") if text.empty?
       push_script(text, true)
     end
 
@@ -354,10 +380,14 @@ END
 
     # Puts a line in <tt>@precompiled</tt> that will add the closing tag of
     # the most recently opened tag.
-    def close_tag(tag)
-      @output_tabs -= 1
+    def close_tag(value)
+      tag, nuke_outer_whitespace, nuke_inner_whitespace = value
+      @output_tabs -= 1 unless nuke_inner_whitespace
       @template_tabs -= 1
-      push_text("</#{tag}>", -1)
+      rstrip_buffer! if nuke_inner_whitespace
+      push_merged_text("</#{tag}>" + (nuke_outer_whitespace ? "" : "\n"),
+                       nuke_inner_whitespace ? 0 : -1, !nuke_inner_whitespace)
+      @dont_indent_next_line = nuke_outer_whitespace
     end
 
     # Closes a Ruby block.
@@ -373,7 +403,7 @@ END
       close_tag = has_conditional ? "<![endif]-->" : "-->"
       push_text(close_tag, -1)
     end
-    
+
     # Closes a loud Ruby block.
     def close_loud(command)
       push_silent 'end', true
@@ -384,14 +414,7 @@ END
     # Closes a filtered block.
     def close_filtered(filter)
       @flat_spaces = -1
-      filtered = filter.new(@filter_buffer).render
-
-      if filter == Haml::Filters::Preserve
-        push_silent("_hamlout.buffer << #{filtered.dump} << \"\\n\";")
-      else
-        push_text(filtered.rstrip.gsub("\n", "\n#{'  ' * @output_tabs}"))
-      end
-
+      filter.internal_compile(self, @filter_buffer)
       @filter_buffer = nil
       @template_tabs -= 1
     end
@@ -400,7 +423,7 @@ END
       @haml_comment = false
       @template_tabs -= 1
     end
-    
+
     # Iterates through the classes and ids supplied through <tt>.</tt>
     # and <tt>#</tt> syntax, and returns a hash with them as attributes,
     # that can then be merged with another attributes hash.
@@ -429,8 +452,8 @@ END
       # $5 holds the value matched by a string
       $2 || $5
     end
-    
-    def parse_static_hash(text)  
+
+    def parse_static_hash(text)
       return {} unless text
 
       attributes = {}
@@ -449,14 +472,23 @@ END
     end
 
     # This is a class method so it can be accessed from Buffer.
-    def self.build_attributes(attr_wrapper, attributes = {})
+    def self.build_attributes(is_html, attr_wrapper, attributes = {})
       quote_escape = attr_wrapper == '"' ? "&quot;" : "&apos;"
       other_quote_char = attr_wrapper == '"' ? "'" : '"'
-  
+
       result = attributes.collect do |attr, value|
         next if value.nil?
 
-        value = value.to_s
+        if value == true
+          next " #{attr}" if is_html
+          next " #{attr}=#{attr_wrapper}#{attr}#{attr_wrapper}"
+        elsif value == false
+          next
+        end
+
+        value = Haml::Helpers.escape_once(value.to_s)
+        # We want to decide whether or not to escape quotes
+        value.gsub!('&quot;', '"')
         this_attr_wrapper = attr_wrapper
         if value.include? attr_wrapper
           if value.include? other_quote_char
@@ -470,47 +502,70 @@ END
       result.compact.sort.join
     end
 
-    def prerender_tag(name, atomic, attributes)
-      "<#{name}#{Precompiler.build_attributes(@options[:attr_wrapper], attributes)}#{atomic ? ' />' : '>'}"
+    def prerender_tag(name, self_close, attributes)
+      attributes_string = Precompiler.build_attributes(html?, @options[:attr_wrapper], attributes)
+      "<#{name}#{attributes_string}#{self_close && xhtml? ? ' /' : ''}>"
     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]
+      raise SyntaxError.new("Invalid tag: \"#{line}\".") unless match = line.scan(/%([-:\w]+)([-\w\.\#]*)(.*)/)[0]
       tag_name, attributes, rest = match
-      if rest[0] == ?{
-        scanner = StringScanner.new(rest)
-        attributes_hash, rest = balance(scanner, ?{, ?})
-        attributes_hash = attributes_hash[1, attributes_hash.length - 2] if attributes_hash
-      end
+      attributes_hash, rest = parse_attributes(rest) if rest[0] == ?{
       if rest
         object_ref, rest = balance(rest, ?[, ?]) if rest[0] == ?[
-        action, value = rest.scan(/([=\/\~]?)?(.*)?/)[0]
+        attributes_hash, rest = parse_attributes(rest) if rest[0] == ?{ && attributes_hash.nil?
+        nuke_whitespace, action, value = rest.scan(/(<>|><|[><])?([=\/\~&!])?(.*)?/)[0]
+        nuke_whitespace ||= ''
+        nuke_outer_whitespace = nuke_whitespace.include? '>'
+        nuke_inner_whitespace = nuke_whitespace.include? '<'
       end
       value = value.to_s.strip
-      [tag_name, attributes, attributes_hash, object_ref, action, value]
+      [tag_name, attributes, attributes_hash, object_ref, nuke_outer_whitespace,
+       nuke_inner_whitespace, action, value]
+    end
+
+    def parse_attributes(line)
+      scanner = StringScanner.new(line)
+      attributes_hash, rest = balance(scanner, ?{, ?})
+      attributes_hash = attributes_hash[1...-1] if attributes_hash
+      return attributes_hash, rest
     end
 
     # Parses a line that will render as an XHTML tag, and adds the code that will
     # render that tag to <tt>@precompiled</tt>.
     def render_tag(line)
-      tag_name, attributes, attributes_hash, object_ref, action, value = parse_tag(line)
-      
+      tag_name, attributes, attributes_hash, object_ref, nuke_outer_whitespace,
+        nuke_inner_whitespace, action, value = parse_tag(line)
+
       raise SyntaxError.new("Illegal element: classes and ids must have values.") if attributes =~ /[\.#](\.|#|\z)/
 
+      # Get rid of whitespace outside of the tag if we need to
+      rstrip_buffer! if nuke_outer_whitespace
+
+      preserve_tag = options[:preserve].include?(tag_name)
+      nuke_inner_whitespace ||= preserve_tag
+
       case action
-      when '/'; atomic = true
-      when '~'; parse = flattened = true
+      when '/'; self_closing = xhtml?
+      when '~'; parse = preserve_script = true
       when '='
         parse = true
         value = unescape_interpolation(value[1..-1].strip) if value[0] == ?=
+      when '&', '!'
+        if value[0] == ?=
+          parse = true
+          value = (value[1] == ?= ? unescape_interpolation(value[2..-1].strip) : value[1..-1].strip)
+        end
       end
-        
+
       if parse && @options[:suppress_eval]
         parse = false
         value = ''
       end
 
+      escape_html = (action == '&' || (action != '!' && @options[:escape_html]))
+
       object_ref = "nil" if object_ref.nil? || @options[:suppress_eval]
 
       static_attributes = parse_static_hash(attributes_hash) # Try pre-compiling a static attributes hash
@@ -518,41 +573,58 @@ END
       attributes = parse_class_and_id(attributes)
       Buffer.merge_attrs(attributes, static_attributes) if static_attributes
 
-      raise SyntaxError.new("Illegal Nesting: Nesting within an atomic tag is illegal.") if @block_opened && atomic
-      raise SyntaxError.new("Illegal Nesting: Content can't be both given on the same line as %#{tag_name} and nested within it.") if @block_opened && !value.empty?
-      raise SyntaxError.new("Tag has no content.") if parse && value.empty?
-      raise SyntaxError.new("Atomic tags can't have content.") if atomic && !value.empty?
+      raise SyntaxError.new("Illegal nesting: nesting within a self-closing tag is illegal.", 1) if @block_opened && self_closing
+      raise SyntaxError.new("Illegal nesting: content can't be both given on the same line as %#{tag_name} and nested within it.", 1) if @block_opened && !value.empty?
+      raise SyntaxError.new("There's no Ruby code for #{action} to evaluate.") if parse && value.empty?
+      raise SyntaxError.new("Self-closing tags can't have content.") if self_closing && !value.empty?
 
-      atomic = true if !@block_opened && value.empty? && @options[:autoclose].include?(tag_name)
-      
-      if object_ref == "nil" && attributes_hash.nil? && !flattened && (parse || Buffer.one_liner?(value))
-        # This means that we can render the tag directly to text and not process it in the buffer
-        tag_closed = !value.empty? && Buffer.one_liner?(value) && !parse
+      self_closing ||= !!( !@block_opened && value.empty? && @options[:autoclose].include?(tag_name) )
 
-        open_tag  = prerender_tag(tag_name, atomic, attributes)
-        open_tag << "#{value}</#{tag_name}>" if tag_closed
-        open_tag << "\n" unless parse
+      dont_indent_next_line =
+        (nuke_outer_whitespace && !@block_opened) ||
+        (nuke_inner_whitespace && @block_opened)
 
-        push_merged_text(open_tag, tag_closed || atomic ? 0 : 1, parse)
+      # Check if we can render the tag directly to text and not process it in the buffer
+      if object_ref == "nil" && attributes_hash.nil? && !preserve_script
+        tag_closed = !@block_opened && !self_closing && !parse
+
+        open_tag  = prerender_tag(tag_name, self_closing, attributes)
+        if tag_closed
+          open_tag << "#{value}</#{tag_name}>"
+          open_tag << "\n" unless nuke_outer_whitespace
+        else
+          open_tag << "\n" unless parse || nuke_inner_whitespace || (self_closing && nuke_outer_whitespace)
+        end
+        
+        push_merged_text(open_tag, tag_closed || self_closing || nuke_inner_whitespace ? 0 : 1,
+                         !nuke_outer_whitespace)
+
+        @dont_indent_next_line = dont_indent_next_line
         return if tag_closed
       else
         flush_merged_text
         content = value.empty? || parse ? 'nil' : value.dump
         attributes_hash = ', ' + attributes_hash if attributes_hash
-        push_silent "_hamlout.open_tag(#{tag_name.inspect}, #{atomic.inspect}, #{(!value.empty?).inspect}, #{attributes.inspect}, #{object_ref}, #{content}#{attributes_hash})"
+        args = [tag_name, self_closing, !@block_opened, preserve_tag, escape_html,
+                attributes, nuke_outer_whitespace, nuke_inner_whitespace
+               ].map { |v| v.inspect }.join(', ')
+        push_silent "_hamlout.open_tag(#{args}, #{object_ref}, #{content}#{attributes_hash})"
+        @dont_tab_up_next_text = @dont_indent_next_line = dont_indent_next_line
       end
-          
-      return if atomic
+
+      return if self_closing
 
       if value.empty?
-        push_and_tabulate([:element, tag_name])
-        @output_tabs += 1
+        push_and_tabulate([:element, [tag_name, nuke_outer_whitespace, nuke_inner_whitespace]])
+        @output_tabs += 1 unless nuke_inner_whitespace
         return
       end
-      
+
       if parse
         flush_merged_text
-        push_script(value, flattened, tag_name)
+        push_script(value, preserve_script, true, preserve_tag, escape_html, nuke_inner_whitespace)
+        @dont_tab_up_next_text = true
+        concat_merged_text("</#{tag_name}>" + (nuke_outer_whitespace ? "" : "\n"))
       end
     end
 
@@ -564,78 +636,105 @@ END
 
     # Renders an XHTML comment.
     def render_comment(line)
-      conditional, content = line.scan(COMMENT_REGEX)[0]
-      content.strip!
+      conditional, line = balance(line, ?[, ?]) if line[0] == ?[
+      line.strip!
       conditional << ">" if conditional
-      
-      if @block_opened && !content.empty?
-        raise SyntaxError.new('Illegal Nesting: Nesting within a tag that already has content is illegal.')
+
+      if @block_opened && !line.empty?
+        raise SyntaxError.new('Illegal nesting: nesting within a tag that already has content is illegal.', 1)
       end
 
       open = "<!--#{conditional} "
-      
+
       # Render it statically if possible
-      if !content.empty? && Buffer.one_liner?(content)
-        return push_text("#{open}#{content} #{conditional ? "<![endif]-->" : "-->"}")
+      unless line.empty?
+        return push_text("#{open}#{line} #{conditional ? "<![endif]-->" : "-->"}")
       end
 
       push_text(open, 1)
       @output_tabs += 1
       push_and_tabulate([:comment, !conditional.nil?])
-      unless content.empty?
-        push_text(content)
+      unless line.empty?
+        push_text(line)
         close
       end
     end
-    
+
     # Renders an XHTML doctype or XML shebang.
     def render_doctype(line)
-      raise SyntaxError.new("Illegal Nesting: Nesting within a header command is illegal.") if @block_opened
-      push_text text_for_doctype(line)
+      raise SyntaxError.new("Illegal nesting: nesting within a header command is illegal.", 1) if @block_opened
+      doctype = text_for_doctype(line)
+      push_text doctype if doctype
     end
 
     def text_for_doctype(text)
       text = text[3..-1].lstrip.downcase
-      if text[0...3] == "xml"
+      if text.index("xml") == 0
+        return nil if html?
         wrapper = @options[:attr_wrapper]
         return "<?xml version=#{wrapper}1.0#{wrapper} encoding=#{wrapper}#{text.split(' ')[1] || "utf-8"}#{wrapper} ?>"
       end
 
-      version, type = text.scan(DOCTYPE_REGEX)[0]
-      if version == "1.1"
-        return '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">'
-      end
+      if html5?
+        '<!DOCTYPE html>'
+      else
+        version, type = text.scan(DOCTYPE_REGEX)[0]
 
-      case type
-      when "strict";   return '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">'
-      when "frameset"; return '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Frameset//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd">'
-      else             return '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">'
+        if xhtml?
+          if version == "1.1"
+            '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">'
+          else
+            case type
+            when "strict";   '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">'
+            when "frameset"; '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Frameset//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd">'
+            else             '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">'
+            end
+          end
+
+        elsif html4?
+          case type
+          when "strict";   '<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">'
+          when "frameset"; '<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Frameset//EN" "http://www.w3.org/TR/html4/frameset.dtd">'
+          else             '<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">'
+          end
+        end
       end
     end
 
     # Starts a filtered block.
     def start_filtered(name)
-      raise SyntaxError.new('Filters must have nested text.') unless @block_opened
+      raise Error.new("Invalid filter name \":#{name}\".") unless name =~ /^\w+$/
 
-      unless filter = options[:filters][name]
+      unless filter = Filters.defined[name]
         if filter == 'redcloth' || filter == 'markdown' || filter == 'textile'
-          raise HamlError.new("You must have the RedCloth gem installed to use \"#{name}\" filter")
+          raise Error.new("You must have the RedCloth gem installed to use \"#{name}\" filter")
         end
-        raise HamlError.new("\"#{name}\" filter is not defined!")
+        raise Error.new("Filter \"#{name}\" is not defined.")
       end
 
       push_and_tabulate([:filtered, filter])
       @flat_spaces = @template_tabs * 2
       @filter_buffer = String.new
+      @block_opened = false
+    end
+
+    def contains_interpolation?(str)
+      str.include?('#{')
     end
 
     def unescape_interpolation(str)
       scan = StringScanner.new(str.dump)
       str = ''
 
-      while scan.scan(/(.*?)\\\#\{/)
-        str << scan.matched[0...-3]
-        str << eval("\"\\\#{#{balance(scan, ?{, ?}, 1)[0][0...-1]}}\"")
+      while scan.scan(/(.*?)(\\+)\#\{/)
+        escapes = (scan[2].size - 1) / 2
+        str << scan.matched[0...-3 - escapes]
+        if escapes % 2 == 1
+          str << '#{'
+        else
+          # Use eval to get rid of string escapes
+          str << '#{' + eval('"' + balance(scan, ?{, ?}, 1)[0][0...-1] + '"') + "}"
+        end
       end
 
       str + scan.rest
@@ -654,18 +753,20 @@ END
 
       raise SyntaxError.new("Unbalanced brackets.")
     end
-    
 
     # Counts the tabulation of a line.
     def count_soft_tabs(line)
       spaces = line.index(/([^ ]|$)/)
       if line[spaces] == ?\t
         return nil if line.strip.empty?
-        raise SyntaxError.new("Illegal Indentation: Only two space characters are allowed as tabulation.")
+        raise SyntaxError.new(<<END.strip, 2)
+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
       end
       [spaces, spaces/2]
     end
-    
+
     # Pushes value onto <tt>@to_close_stack</tt> and increases
     # <tt>@template_tabs</tt>.
     def push_and_tabulate(value)
@@ -677,10 +778,30 @@ END
       @flat_spaces != -1
     end
 
-    def newline(skip_next = false)
-      return @skip_next_newline = false if @skip_next_newline
-      @skip_next_newline = true if skip_next
+    def newline
+      @newlines += 1
+    end
+
+    def newline_now
       @precompiled << "\n"
+      @newlines -= 1
+    end
+
+    def resolve_newlines
+      return unless @newlines > 0
+      @precompiled << "\n" * @newlines
+      @newlines = 0
+    end
+
+    # Get rid of and whitespace at the end of the buffer
+    # or the merged text
+    def rstrip_buffer!
+      unless @merged_text.empty?
+        @merged_text.rstrip!
+      else
+        push_silent("_erbout.rstrip!", false)
+        @dont_tab_up_next_text = true
+      end
     end
   end
 end