haml 1.5.2 → 1.7.0

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2006 Hampton Catlin
+Copyright (c) 2006-2007 Hampton Catlin
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/Rakefile

@@ -103,6 +103,7 @@ unless ARGV[0] == 'benchmark'
     rdoc.rdoc_files.include('README')
     rdoc.rdoc_files.include('lib/**/*.rb')
     rdoc.rdoc_files.exclude('lib/haml/buffer.rb')
+    rdoc.rdoc_files.exclude('lib/haml/util.rb')
     rdoc.rdoc_files.exclude('lib/sass/tree/*')
   end
 

data/VERSION

@@ -1 +1 @@
-1.5.2
+1.7.0

data/bin/css2sass

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../lib/haml'
+require 'haml/exec'
+
+opts = Haml::Exec::CSS2Sass.new(ARGV)
+opts.parse!

data/bin/html2haml

@@ -1,88 +1,6 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../lib/haml'
-require 'haml/engine'
-require 'rubygems'
-require 'hpricot'
-
-def tabulate(tabs)
-  '  ' * tabs
-end
-
-TEXT_REGEXP = /^(\s*).*$/
-
-def parse_text(text, tabs)
-  text.strip!
-  if text.empty?
-    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"
-    end.join
-  end
-end
-
-module Hpricot::Node
-  def to_haml(tabs)
-    parse_text(self.to_s, tabs)
-  end
-end
-
-class Hpricot::Doc
-  def to_haml
-    output = ''
-    children.each { |child| output += child.to_haml(0) }
-    output
-  end
-end
-
-class Hpricot::XMLDecl
-  def to_haml(tabs)
-    "#{tabulate(tabs)}!!! XML\n"
-  end
-end
-
-class Hpricot::DocType
-  def to_haml(tabs)
-    "#{tabulate(tabs)}!!!\n"
-  end
-end
-
-class Hpricot::Comment
-  def to_haml(tabs)
-    "#{tabulate(tabs)}/\n#{parse_text(self.content, tabs + 1)}"
-  end
-end
-
-class Hpricot::Elem
-  def to_haml(tabs)
-    output = "#{tabulate(tabs)}"
-    output += "%#{name}" unless name == 'div'
-      
-    if attributes
-      output += "##{attributes['id']}" if attributes['id']
-      attributes['class'].split(' ').each { |c| output += ".#{c}" } if attributes['class']
-      attributes.delete("id")
-      attributes.delete("class")
-      output += attributes.inspect if attributes.length > 0
-    end
-  
-    output += "/" if children.length == 0
-    output += "\n"
-
-    self.children.each do |child|
-      output += child.to_haml(tabs + 1)
-    end
-
-    output
-  end
-end
-
-# Must be required after Hpricot mods,
-# so they're in scope
 require 'haml/exec'
 
 opts = Haml::Exec::HTML2Haml.new(ARGV)

data/lib/haml.rb

@@ -78,7 +78,7 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir)
 #
 #   engine = Haml::Engine.new("%p Haml code!")
 #   engine.render #=> "<p>Haml code!</p>\n"
-# 
+#
 # == Characters with meaning to Haml
 # 
 # Various characters, when placed at a certain point in a line,
@@ -181,6 +181,19 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir)
 # 
 #   <br />
 #   <meta http-equiv='Content-Type' content='text/html' />
+#
+# Some tags are automatically closed, as long as they have no content.
+# +meta+, +img+, +link+, +script+, +br+, and +hr+ tags are closed by default.
+# This list can be customized by setting the <tt>:autoclose</tt> option (see below).
+# For example:
+#
+#   %br
+#   %meta{'http-equiv' => 'Content-Type', :content => 'text/html'}
+#
+# is also compiled to:
+#
+#   <br />
+#   <meta http-equiv='Content-Type' content='text/html' />
 # 
 # ==== . and #
 # 
@@ -524,6 +537,20 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir)
 #     hi there reader!
 #     yo
 #   </p>
+#
+# You can also use two equal signs, <tt>==</tt>,
+# along with conventional Ruby string-embedding syntax
+# to easily embed Ruby code in otherwise static text.
+# For example:
+#
+#   %p
+#     == 1 + 1 = #{1 + 1}
+#
+# is compiled to:
+#
+#   <p>
+#     1 + 1 = 2
+#   </p>
 # 
 # ==== -
 # 
@@ -595,8 +622,18 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir)
 #   <p>
 #     2?
 #   </p>
+#
+# == Other Useful Things
+#
+# === Helpers
+#
+# Haml offers a bunch of helpers that are useful
+# for doing stuff like preserving whitespace,
+# creating nicely indented output for user-defined helpers,
+# and other useful things.
+# The helpers are all documented in the Haml::Helpers and Haml::Helpers::ActionViewExtensions modules.
 # 
-# == Haml Options
+# === Haml Options
 # 
 # Options can be set by setting the hash <tt>Haml::Template.options</tt>
 # from <tt>environment.rb</tt> in Rails,
@@ -608,10 +645,6 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir)
 #                           evaluated. If this is true, said scripts are
 #                           rendered as empty strings. Defaults to false.
 # 
-# [<tt>:precompiled</tt>]   A string containing a precompiled Haml template.
-#                           If this is passed, <tt>template</tt> is ignored
-#                           and no precompilation is done.
-# 
 # [<tt>:attr_wrapper</tt>]  The character that should wrap element attributes.
 #                           This defaults to <tt>'</tt> (an apostrophe). Characters
 #                           of this type within the attributes will be escaped
@@ -638,6 +671,10 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir)
 #                           <tt>{ :foo => "bar" }</tt>, then within the template,
 #                           <tt>= foo</tt> will produce <tt>bar</tt>.
 #
+# [<tt>:autoclose</tt>]     A list of tag names that should be automatically self-closed
+#                           if they have no content.
+#                           Defaults to <tt>['meta', 'img', 'link', 'script', 'br', 'hr']</tt>.
+#
 module Haml; end
 
 require 'haml/engine'

data/lib/haml/buffer.rb

@@ -15,9 +15,16 @@ module Haml
     # _erbout for compatibility with ERB-specific code.
     attr_accessor :buffer
 
-    # The number of tabs that are added or subtracted from the
-    # tabulation proscribed by the precompiled template.
-    attr_accessor :tabulation
+    # Gets the current tabulation of the document.
+    def tabulation
+      @real_tabs + @tabulation
+    end
+
+    # Sets the current tabulation of the document.
+    def tabulation=(val)
+      val = val - @real_tabs
+      @tabulation = val > -1 ? val : 0
+    end
 
     # Creates a new buffer.
     def initialize(options = {})
@@ -27,17 +34,16 @@ module Haml
       @buffer = ""
       @one_liner_pending = false
       @tabulation = 0
+
+      # The number of tabs that Engine thinks we should have
+      # @real_tabs + @tabulation is the number of tabs actually output
+      @real_tabs = 0
     end
 
     # Renders +text+ with the proper tabulation. This also deals with
     # making a possible one-line tag one line or not.
-    def push_text(text, tabulation, flattened = false)
-      if flattened
-        # In this case, tabulation is the number of spaces, rather
-        # than the number of tabs.
-        @buffer << "#{' ' * tabulation}#{flatten(text + "\n")}"
-        @one_liner_pending = true
-      elsif @one_liner_pending && one_liner?(text)
+    def push_text(text, tabulation)
+      if @one_liner_pending && Buffer.one_liner?(text)
         @buffer << text
       else
         if @one_liner_pending
@@ -66,14 +72,21 @@ module Haml
       end
       nil
     end
+    
+    def open_prerendered_tag(tag, tabulation)
+      @buffer << "#{tabs(tabulation)}#{tag}"
+      @real_tabs += 1
+    end
 
     # Takes the various information about the opening tag for an
     # element, formats it, and adds it to the buffer.
-    def open_tag(name, tabulation, atomic, try_one_line, class_id, attributes_hash, obj_ref, flattened)
-      attributes = {}
-      attributes.merge!(parse_class_and_id(class_id)) unless class_id.nil? || class_id.empty?
-      attributes.merge!(parse_object_ref(obj_ref, attributes[:id], attributes[:class])) if obj_ref
-      attributes.merge!(attributes_hash) if attributes_hash
+    def open_tag(name, tabulation, atomic, try_one_line, class_id, obj_ref, attributes_hash)
+      attributes = class_id
+      if attributes_hash
+        attributes_hash.keys.each { |key| attributes_hash[key.to_s] = attributes_hash.delete(key) }
+        self.class.merge_attrs(attributes, attributes_hash)
+      end
+      self.class.merge_attrs(attributes, parse_object_ref(obj_ref)) if obj_ref
 
       @one_liner_pending = false
       if atomic
@@ -81,12 +94,24 @@ module Haml
       elsif try_one_line
         @one_liner_pending = true
         str = ">"
-      elsif flattened
-        str = ">&#x000A;"
       else
         str = ">\n"
       end
       @buffer << "#{tabs(tabulation)}<#{name}#{build_attributes(attributes)}#{str}"
+      @real_tabs += 1
+    end
+
+    def self.merge_attrs(to, from)
+      if to['id'] && from['id']
+        to['id'] << '_' << from.delete('id')
+      end
+
+      if to['class'] && from['class']
+        # Make sure we don't duplicate class names
+        from['class'] = (from['class'].split(' ') | to['class'].split(' ')).join(' ')
+      end
+
+      to.merge!(from)
     end
 
     # Creates a closing tag with the given name.
@@ -107,6 +132,7 @@ module Haml
         @one_liner_pending = true
       else
         @buffer << "\n"
+        @real_tabs += 1
       end
     end
 
@@ -120,60 +146,9 @@ module Haml
         push_text(close_tag, tabulation)
       end
     end
-    
-    # Stops parsing a flat section.
-    def stop_flat
-      buffer.concat("\n")
-      @one_liner_pending = false
-    end
-
-    private
-
-    # Gets <tt>count</tt> tabs. Mostly for internal use.
-    def tabs(count)
-      '  ' * (count + @tabulation)
-    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.
-    def parse_class_and_id(list)
-      attributes = {}
-      list.scan(/([#.])([-_a-zA-Z0-9]+)/) do |type, property|
-        case type
-        when '.'
-          if attributes[:class]
-            attributes[:class] += " "
-          else
-            attributes[:class] = ""
-          end
-          attributes[:class] += property
-        when '#'
-          attributes[:id] = property
-        end
-      end
-      attributes
-    end
-
-    # Takes an array of objects and uses the class and id of the first
-    # one to create an attributes hash.
-    def parse_object_ref(ref, old_id, old_class)
-      ref = ref[0]
-      # Let's make sure the value isn't nil. If it is, return the default Hash.
-      return {} if ref.nil?
-      class_name = ref.class.to_s.underscore
-      id = "#{class_name}_#{ref.id}"
-
-      if old_class
-        class_name += " #{old_class}"
-      end
 
-      if old_id
-        id = "#{old_id}_#{id}"
-      end
-
-      {:id => id, :class => class_name}
-    end
+    # Some of these methods are exposed as public class methods
+    # so they can be re-used in helpers.
 
     # Takes a hash and builds a list of XHTML attributes from it, returning
     # the result.
@@ -194,12 +169,46 @@ module Haml
       end
       result.sort.join
     end
-
+    
     # Returns whether or not the given value is short enough to be rendered
     # on one line.
-    def one_liner?(value)
+    def self.one_liner?(value)
       value.length <= ONE_LINER_LENGTH && value.scan(/\n/).empty?
     end
+
+    private
+
+    @@tab_cache = {}
+    # Gets <tt>count</tt> tabs. Mostly for internal use.
+    def tabs(count)
+      @real_tabs = count
+      tabs = count + @tabulation
+      '  ' * tabs
+      @@tab_cache[tabs] ||= '  ' * tabs
+    end
+
+    # Takes an array of objects and uses the class and id of the first
+    # one to create an attributes hash.
+    def parse_object_ref(ref)
+      ref = ref[0]
+      # Let's make sure the value isn't nil. If it is, return the default Hash.
+      return {} if ref.nil?
+      class_name = underscore(ref.class)
+      id = "#{class_name}_#{ref.id || 'new'}"
+
+      {'id' => id, 'class' => class_name}
+    end
+
+    # Changes a word from camel case to underscores.
+    # Based on the method of the same name in Rails' Inflector,
+    # but copied here so it'll run properly without Rails.
+    def underscore(camel_cased_word)
+      camel_cased_word.to_s.gsub(/::/, '_').
+        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        tr("-", "_").
+        downcase
+    end
   end
 end
 

data/lib/haml/engine.rb

@@ -2,6 +2,7 @@ require 'haml/helpers'
 require 'haml/buffer'
 require 'haml/filters'
 require 'haml/error'
+require 'haml/util'
 
 module Haml
   # This is the class where all the parsing and processing of the Haml
@@ -13,9 +14,6 @@ module Haml
   #   output = haml_engine.to_html
   #   puts output
   class Engine
-    # Allow access to the precompiled template
-    attr_reader :precompiled
-
     # Allow reading and writing of the options hash
     attr :options, true
 
@@ -93,13 +91,16 @@ module Haml
     MID_BLOCK_KEYWORDS   = ['else', 'elsif', 'rescue', 'ensure', 'when']
 
     # The Regex that matches an HTML comment command.
-    COMMENT_REGEX = /\/(\[[a-zA-Z0-9 \.]*\])?(.*)/
+    COMMENT_REGEX = /\/(\[[\w\s\.]*\])?(.*)/
 
     # The Regex that matches a Doctype command.
-    DOCTYPE_REGEX = /([0-9]\.[0-9])?[\s]*([a-zA-Z]*)/
+    DOCTYPE_REGEX = /(\d\.\d)?[\s]*([a-z]*)/i
 
     # The Regex that matches an HTML tag command.
-    TAG_REGEX = /[%]([-:_a-zA-Z0-9]+)([-_a-zA-Z0-9\.\#]*)(\{.*\})?(\[.*\])?([=\/\~]?)?(.*)?/
+    TAG_REGEX = /[%]([-:\w]+)([-\w\.\#]*)(\{.*\})?(\[.*\])?([=\/\~]?)?(.*)?/
+
+    # The Regex that matches a literal string or symbol value
+    LITERAL_VALUE_REGEX = /^\s*(:(\w*)|(('|")([^\\\#]*?)\4))\s*$/
 
     FLAT_WARNING = <<END
 Haml deprecation warning:
@@ -109,7 +110,7 @@ helper instead.
 END
 
     # Creates a new instace of Haml::Engine that will compile the given
-    # template string when <tt>to_html</tt> is called.
+    # template string when <tt>render</tt> is called.
     # See README for available options.
     #
     #--
@@ -117,16 +118,16 @@ END
     # to README!
     #++
     #
-    def initialize(template, options = {})
+    def initialize(template, l_options = {})
       @options = {
         :suppress_eval => false,
         :attr_wrapper => "'",
         :locals => {},
+        :autoclose => ['meta', 'img', 'link', 'script', 'br', 'hr'],
         :filters => {
           'sass' => Sass::Engine,
           'plain' => Haml::Filters::Plain,
-          'preserve' => Haml::Filters::Preserve
-        }
+          'preserve' => Haml::Filters::Preserve }
       }
 
       if !NOT_LOADED.include? 'redcloth'
@@ -140,7 +141,7 @@ END
         @options[:filters]['markdown'] = Haml::Filters::Markdown
       end
 
-      @options.rec_merge! options
+      @options.rec_merge! l_options
 
       unless @options[:suppress_eval]
         @options[:filters].merge!({
@@ -148,9 +149,7 @@ END
           'ruby' => Haml::Filters::Ruby
         })
       end
-      @options[:filters].rec_merge! options[:filters] if options[:filters]
-
-      @precompiled = @options[:precompiled]
+      @options[:filters].rec_merge! l_options[:filters] if l_options[:filters]
 
       @template = template.strip #String
       @to_close_stack = []
@@ -165,7 +164,13 @@ END
       begin
         # Only do the first round of pre-compiling if we really need to.
         # They might be passing in the precompiled string.
-        do_precompile if @precompiled.nil? && (@precompiled = String.new)
+        requires_precompile = true
+        if @@method_names[@template]
+          # Check that the compiled method supports a superset of the local assigns we want to do
+          supported_assigns = @@supported_local_assigns[@template]
+          requires_precompile = !@options[:locals].keys.all? {|var| supported_assigns.include? var}
+        end
+        do_precompile if requires_precompile
       rescue Haml::Error => e
         e.add_backtrace_entry(@index, @options[:filename])
         raise e
@@ -177,17 +182,7 @@ END
       @scope_object = scope
       @buffer = Haml::Buffer.new(@options)
 
-      local_assigns = @options[:locals]
-
-      # Get inside the view object's world
-      @scope_object.instance_eval do
-        # Set all the local assigns
-        local_assigns.each do |key,val|
-          self.class.send(:define_method, key) { val }
-        end
-      end
-
-      # Compile the @precompiled buffer
+      # Run the compiled evaluator function
       compile &block
 
       # Return the result string
@@ -196,17 +191,36 @@ END
 
     alias_method :to_html, :render
 
-   private
+    # This method is deprecated and shouldn't be used.
+    def precompiled
+      $stderr.puts <<END
+The Haml precompiled method and :precompiled option
+are deprecated and will be removed in version 2.0.
+Haml::Engine now automatically handles caching.
+END
+      nil
+    end
 
+   private
+    
     #Precompile each line
     def do_precompile
+      @precompiled = ''
+      method_name = assign_method_name(@template, options[:filename])
       push_silent <<-END
-        def _haml_render
-        @haml_is_haml = true
-        _hamlout = @haml_stack[-1]
-        _erbout = _hamlout.buffer
+        def #{method_name}(_haml_local_assigns)
+          @haml_is_haml = true
+          _hamlout = @haml_stack[-1]
+          _erbout = _hamlout.buffer
       END
       
+      supported_local_assigns = {}
+      @@supported_local_assigns[@template] = supported_local_assigns
+      @options[:locals].each do |k,v|
+        supported_local_assigns[k] = true
+        push_silent "#{k} = _haml_local_assigns[:#{k}]"
+      end
+      
       old_line = nil
       old_index = nil
       old_spaces = nil
@@ -236,7 +250,7 @@ END
 
               if flat
                 push_flat(old_uline, old_spaces)
-              elsif !line_empty
+              elsif !line_empty && !@haml_comment
                 process_line(old_line, old_index, block_opened)
               end
 
@@ -266,8 +280,7 @@ END
       # Close all the open tags
       @template_tabs.times { close }
 
-      push_silent "@haml_is_haml = false"
-      push_silent "end"
+      push_silent "@haml_is_haml = false\nend\n"
     end
     
     # Processes and deals with lowering indentation.
@@ -302,12 +315,11 @@ END
       when SCRIPT
         sub_line = line[1..-1]
         if sub_line[0] == SCRIPT
-          push_script(sub_line[1..-1].strip.dump.gsub('\\#', '#'), false)
+          push_script(unescape_interpolation(sub_line[1..-1].strip), false)
         else
           push_script(sub_line, false)
         end
       when FLAT_SCRIPT
-        warn(FLAT_WARNING) unless defined?(Test::Unit)
         push_flat_script(line[1..-1])
       when SILENT_SCRIPT
         sub_line = line[1..-1]
@@ -317,6 +329,8 @@ END
           if (@block_opened && !mbk) || line[1..-1].split(' ', 2)[0] == "case"
             push_and_tabulate([:script])
           end
+        else
+          start_haml_comment
         end
       when FILTER
         name = line[1..-1].downcase
@@ -374,6 +388,23 @@ END
     def is_multiline?(line)                                          # ' '[0] == 32
       line && line.length > 1 && line[-1] == MULTILINE_CHAR_VALUE && line[-2] == 32
     end
+    
+    # Method for generating compiled method names basically ripped out of ActiveView::Base
+    # If Haml is to be used as a standalone module without rails and still use the precompiled
+    # methods technique, it will end up duplicating this stuff.  I can't decide whether
+    # checking compile times to decide whether to recompile a template belongs in here or
+    # out in template.rb
+    @@method_names = {}
+    @@supported_local_assigns = {}
+    @@render_method_count = 0
+    def assign_method_name(template, file_name)
+      @@render_method_count += 1
+      @@method_names[template] = "_render_haml_#{@@render_method_count}".intern
+    end
+    
+    module CompiledTemplates
+      # holds compiled template code
+    end
 
     # Takes <tt>@precompiled</tt>, a string buffer of Ruby code, and
     # evaluates it in the context of <tt>@scope_object</tt>, after preparing
@@ -391,11 +422,17 @@ END
           attr :haml_lineno # :nodoc:
         end
       end
+      @scope_object.class.instance_eval do
+        include CompiledTemplates
+      end
 
       begin
-        # Evaluate the buffer in the context of the scope object
-        @scope_object.instance_eval @precompiled
-        @scope_object._haml_render &block
+        method_name = @@method_names[@template]
+
+        unless @scope_object.respond_to?(method_name)
+          CompiledTemplates.module_eval @precompiled
+        end
+        @scope_object.send(method_name, options[:locals], &block)
       rescue Exception => e
         class << e
           include Haml::Error
@@ -408,9 +445,13 @@ END
         compile_error = e.message.scan(/\(eval\):([0-9]*):in `[-_a-zA-Z]*': compile error/)[0]
 
         if compile_error
-          eval_line = compile_error[0].to_i
-          line_marker = @precompiled.split("\n")[0...eval_line].grep(/@haml_lineno = [0-9]*/)[-1]
-          lineno = line_marker.scan(/[0-9]+/)[0].to_i if line_marker
+          if @precompiled
+            eval_line = compile_error[0].to_i
+            line_marker = @precompiled.split("\n")[0...eval_line].grep(/@haml_lineno = [0-9]*/)[-1]
+            lineno = line_marker.scan(/[0-9]+/)[0].to_i if line_marker
+          else
+            lineno = -1
+          end
         end
 
         e.add_backtrace_entry(lineno, @options[:filename])
@@ -426,7 +467,7 @@ END
     # Evaluates <tt>text</tt> in the context of <tt>@scope_object</tt>, but
     # does not output the result.
     def push_silent(text, add_index = false, can_suppress = false)
-      unless can_suppress && @options[:suppress_eval]
+      unless (can_suppress && options[:suppress_eval])
         if add_index
           @precompiled << "@haml_lineno = #{@index}\n#{text}\n"
         else
@@ -455,11 +496,7 @@ END
     def push_flat(text, spaces)
       tabulation = spaces - @flat_spaces
       tabulation = tabulation > -1 ? tabulation : 0
-      if @filter_buffer
-        @filter_buffer << "#{' ' * tabulation}#{text}\n"
-      else
-        @precompiled << "_hamlout.push_text(#{text.dump}, #{tabulation}, true)\n"
-      end
+      @filter_buffer << "#{' ' * tabulation}#{text}\n"
     end
 
     # Causes <tt>text</tt> to be evaluated in the context of
@@ -482,13 +519,17 @@ 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)
-      unless text.empty?
-        push_script(text, true)
+      if text.empty?
+        raise SyntaxError.new("Tag has no content.")
       else
-        unless @block_opened
-          raise SyntaxError.new('Filters must have nested text.')
-        end
-        start_flat(false)
+        push_script(text, true)
+      end
+    end
+
+    def start_haml_comment
+      if @block_opened
+        @haml_comment = true
+        push_and_tabulate([:haml_comment])
       end
     end
 
@@ -502,12 +543,12 @@ END
         close_comment value
       when :element
         close_tag value
-      when :flat
-        close_flat value
       when :loud
         close_loud value
       when :filtered
         close_filtered value
+      when :haml_comment
+        close_haml_comment
       end
     end
 
@@ -532,17 +573,6 @@ END
       push_silent "_hamlout.close_comment(#{has_conditional}, #{@output_tabs})"
     end
     
-    # Closes a flattened section.
-    def close_flat(in_tag)
-      @flat_spaces = -1
-      if in_tag
-        close
-      else
-        push_silent('_hamlout.stop_flat')
-        @template_tabs -= 1
-      end
-    end
-    
     # Closes a loud Ruby block.
     def close_loud(command)
       push_silent 'end', false, true
@@ -573,43 +603,167 @@ END
       @template_tabs -= 1
     end
 
+    def close_haml_comment
+      @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.
+    def parse_class_and_id(list)
+      attributes = {}
+      list.scan(/([#.])([-_a-zA-Z0-9]+)/) do |type, property|
+        case type
+        when '.'
+          if attributes['class']
+            attributes['class'] += " "
+          else
+            attributes['class'] = ""
+          end
+          attributes['class'] += property
+        when '#'
+          attributes['id'] = property
+        end
+      end
+      attributes
+    end
+
+    def parse_literal_value(text)
+      text.match(LITERAL_VALUE_REGEX)
+
+      # $2 holds the value matched by a symbol, but is nil for a string match
+      # $5 holds the value matched by a string
+      $2 || $5
+    end
+    
+    def parse_literal_hash(text)  
+      unless text
+        return {}
+      end
+      
+      attributes = {}
+      if inner = text.scan(/^\{(.*)\}$/)[0]
+        inner[0].split(',').each do |attrib|
+          key, value, more = attrib.split('=>')
+
+          # Make sure the key and value and only the key and value exist
+          # Otherwise, it's too complicated and we'll defer it to the actual Ruby parser
+          if more || (key = parse_literal_value(key)).nil? ||
+              (value = parse_literal_value(value)).nil?
+            return nil
+          end
+
+          attributes[key] = value
+        end
+      end
+      attributes
+    end
+
+    def build_attributes(attributes = {})
+      @quote_escape = @options[:attr_wrapper] == '"' ? "&quot;" : "&apos;"
+      @other_quote_char = @options[:attr_wrapper] == '"' ? "'" : '"'
+  
+      result = attributes.collect do |a,v|
+        v = v.to_s
+        unless v.nil? || v.empty?
+          attr_wrapper = @options[:attr_wrapper]
+          if v.include? attr_wrapper
+            if v.include? @other_quote_char
+              # An imperfection in LITERAL_VALUE_REGEX prevents this
+              # from ever actually being reached,
+              # but in case it becomes possible,
+              # I'm leaving it in.
+              v = v.gsub(attr_wrapper, @quote_escape)
+            else
+              attr_wrapper = @other_quote_char
+            end
+          end
+          " #{a}=#{attr_wrapper}#{v}#{attr_wrapper}"
+        end
+      end
+      result.sort.join
+    end
+
+    def prerender_tag(name, atomic, attributes)
+      if atomic
+        str = " />"
+      else
+        str = ">"
+      end
+  
+      "<#{name}#{build_attributes(attributes)}#{str}"
+    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)
       matched = false
       line.scan(TAG_REGEX) do |tag_name, attributes, attributes_hash, object_ref, action, value|
         matched = true
-        value = value.to_s
+        value = value.to_s.strip
 
         case action
         when '/'
           atomic = true
         when '=', '~'
           parse = true
-        else
-          value = value.strip
+
+          if value.first == '='
+            value = value[1..-1].strip.dump.gsub('\\#', '#')
+          end
         end
 
         flattened = (action == '~')
         
-        warn(FLAT_WARNING) if flattened && !defined?(Test::Unit)
-
         value_exists = !value.empty?
-        attributes_hash = "nil" if attributes_hash.nil? || @options[:suppress_eval]
+        literal_attributes = parse_literal_hash(attributes_hash)
+        attributes_hash = "{nil}" if attributes_hash.nil? || literal_attributes || @options[:suppress_eval]
         object_ref = "nil" if object_ref.nil? || @options[:suppress_eval]
 
-        if @block_opened 
+        if !attributes.empty? && '.#'.include?(attributes)
+          raise SyntaxError.new("Illegal element: classes and ids must have values. Use %div instead.")
+        end
+        
+        # Preparse the attributes hash
+        attributes = parse_class_and_id(attributes)
+        Buffer.merge_attrs(attributes, literal_attributes) if literal_attributes
+
+        if @block_opened
           if atomic
             raise SyntaxError.new("Illegal Nesting: Nesting within an atomic tag is illegal.")
           elsif action == '=' || value_exists
             raise SyntaxError.new("Illegal Nesting: Nesting within a tag that already has content is illegal.")
           end
+        elsif atomic && value_exists
+          raise SyntaxError.new("Atomic tags can't have content.")
         elsif parse && !value_exists
-          raise SyntaxError.new("No tag content to parse.")
+          raise SyntaxError.new("Tag has no content.")
         end
 
-        push_silent "_hamlout.open_tag(#{tag_name.inspect}, #{@output_tabs}, #{atomic.inspect}, #{value_exists.inspect}, #{attributes.inspect}, #{attributes_hash}, #{object_ref}, #{flattened.inspect})", true
-
+        if !@block_opened && !value_exists && @options[:autoclose].include?(tag_name)
+          atomic = true
+        end
+        
+        do_one_liner = value_exists && !parse && Buffer.one_liner?(value)
+        
+        if object_ref == "nil" && attributes_hash == "{nil}" && !flattened && (do_one_liner || !value_exists)
+          # This means that we can render the tag directly to text and not process it in the buffer
+          open_tag = prerender_tag(tag_name, atomic, attributes)
+          
+          if do_one_liner
+            open_tag += value
+            open_tag += "</#{tag_name}>"
+          end
+          
+          open_tag += "\n"
+            
+          push_silent "_hamlout.open_prerendered_tag(#{open_tag.dump}, #{@output_tabs})"
+          return if do_one_liner
+        else
+          push_silent "_hamlout.open_tag(#{tag_name.inspect}, #{@output_tabs}, #{atomic.inspect}, #{value_exists.inspect}, #{attributes.inspect}, #{object_ref}, #{attributes_hash[1...-1]})", true
+        end
+          
         unless atomic
           push_and_tabulate([:element, tag_name])
           @output_tabs += 1
@@ -622,7 +776,7 @@ END
             end
             close
           elsif flattened
-            start_flat(true)
+            raise SyntaxError.new("Tag has no content.")
           end
         end
       end
@@ -684,18 +838,6 @@ END
       end
       push_text doctype
     end
-    
-    # Starts a flattened block.
-    def start_flat(in_tag)
-      # @flat_spaces is the number of indentations in the template
-      # that forms the base of the flattened area
-      if in_tag
-        @to_close_stack.push([:flat, true])
-      else
-        push_and_tabulate([:flat])
-      end
-      @flat_spaces = @template_tabs * 2
-    end
 
     # Starts a filtered block.
     def start_filtered(filter)
@@ -707,10 +849,18 @@ END
       @filter_buffer = String.new
     end
 
+    def unescape_interpolation(str)
+      str.dump.gsub('\\#', '#').gsub(/\#\{[^\}]+\}/) do |substr|
+        substr.gsub('\\"', '"')
+      end
+    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.")
       end
       [spaces, spaces/2]
@@ -724,23 +874,3 @@ END
     end
   end
 end
-
-class Hash # :nodoc:
-  # Same as Hash#merge!, but recursively merges sub-hashes.
-  def rec_merge!(other)
-    other.each do |key, value|
-      myval = self[key]
-      if value.is_a?(Hash) && myval.is_a?(Hash)
-        myval.rec_merge!(value)
-      else
-        self[key] = value
-      end
-    end
-    self
-  end
-
-  def rec_merge(other)
-    toret = self.clone
-    toret.rec_merge! other
-  end
-end