haml 1.0.0

data/Rakefile

@@ -0,0 +1,167 @@
+require 'rubygems'
+require 'rake'
+
+volatile_requires = ['rcov/rcovtask']
+not_loaded = []
+volatile_requires.each do |file|
+  begin
+    require file
+  rescue LoadError
+    not_loaded.push file
+  end
+end
+
+# For some crazy reason,
+# some Rake tasks interfere with others
+# (specifically, benchmarking).
+# Thus, it's advantageous to only show
+# the task currently being used.
+def is_task?(*tasks)
+  ARGV[0].nil? || tasks.include?(ARGV[0])
+end
+
+# ----- Default: Testing ------
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+if is_task?('test', 'default')
+  require 'rake/testtask'
+
+  desc 'Test the Haml plugin'
+  Rake::TestTask.new(:test) do |t|
+    t.libs << 'lib'
+    t.pattern = 'test/**/*_test.rb'
+    t.verbose = true
+  end
+end
+
+# ----- Packaging -----
+
+if is_task?('package', 'repackage', 'clobber_package')
+  require 'rake/gempackagetask'
+  
+  spec = Gem::Specification.new do |spec|
+    spec.name = 'haml'
+    spec.summary = 'An elegant, structured XHTML/XML templating engine.'
+    spec.version = File.read('VERSION').strip
+    spec.author = 'Hampton Catlin'
+    spec.email = 'haml@googlegroups.com'
+    spec.description = <<-END
+      Haml (HTML Abstraction Markup Language) is a layer on top of XHTML or XML
+      that's designed to express the structure of XHTML or XML documents
+      in a non-repetitive, elegant, easy way,
+      using indentation rather than closing tags
+      and allowing Ruby to be embedded with ease.
+      It was originally envisioned as a plugin for Ruby on Rails,
+      but it can function as a stand-alone templating engine.
+    END
+    
+    readmes = FileList.new('*') { |list| list.exclude(/[a-z]/) }.to_a
+    spec.executables = ['haml']
+    spec.files = FileList['lib/**/*', 'bin/*', 'test/**/*', 'Rakefile'].to_a + readmes
+    spec.homepage = 'http://haml.hamptoncatlin.com/'
+    spec.has_rdoc = true
+    spec.extra_rdoc_files = readmes
+    spec.rdoc_options += [
+      '--title', 'Haml',
+      '--main', 'REFERENCE',
+      '--exclude', 'lib/haml/buffer.rb',
+      '--line-numbers',
+      '--inline-source'
+    ]
+    spec.test_files = FileList['test/**/*_test.rb'].to_a
+  end
+  
+  Rake::GemPackageTask.new(spec) { |pkg| }
+end
+
+# ----- Benchmarking -----
+
+if is_task?('benchmark')
+  temp_desc = <<END
+Benchmark HAML against ERb.
+  TIMES=n sets the number of runs. Defaults to 100.
+END
+  
+  desc temp_desc.chomp
+  task :benchmark do
+    require 'test/benchmark'
+
+    puts '-'*51, "Benchmark: Haml vs. ERb", '-'*51
+    puts "Running benchmark #{ENV['TIMES']} times..." if ENV['TIMES']
+    times = ENV['TIMES'].to_i if ENV['TIMES']
+    benchmarker = Haml::Benchmarker.new
+    puts benchmarker.benchmark(times || 100)
+    puts '-'*51
+  end
+end
+
+# ----- Documentation -----
+
+if is_task?('rdoc', 'rerdoc', 'clobber_rdoc', 'rdoc_devel', 'rerdoc_devel', 'clobber_rdoc_devel')
+  require 'rake/rdoctask'
+  
+  rdoc_task = Proc.new do |rdoc|
+    rdoc.title    = 'Haml'
+    rdoc.options << '--line-numbers' << '--inline-source'
+    rdoc.rdoc_files.include('REFERENCE')
+    rdoc.rdoc_files.include('lib/**/*.rb')
+    rdoc.rdoc_files.exclude('lib/haml/buffer.rb')
+  end
+
+  Rake::RDocTask.new do |rdoc|
+    rdoc_task.call(rdoc)
+    rdoc.rdoc_dir = 'rdoc'
+  end
+
+  Rake::RDocTask.new(:rdoc_devel) do |rdoc|
+    rdoc_task.call(rdoc)
+    rdoc.rdoc_dir = 'rdoc_devel'
+    rdoc.options << '--all'
+    rdoc.rdoc_files.include('test/*.rb')
+    rdoc.rdoc_files = Rake::FileList.new(*rdoc.rdoc_files.to_a)
+    rdoc.rdoc_files.include('lib/haml/buffer.rb')
+  end
+end
+
+# ----- Coverage -----
+
+if is_task?('rcov', 'clobber_rcov')
+  unless not_loaded.include? 'rcov/rcovtask'
+    Rcov::RcovTask.new do |t|
+      t.libs << "test"
+      t.test_files = FileList['test/**/*_test.rb']
+      if ENV['NON_NATIVE']
+        t.rcov_opts << "--no-rcovrt"
+      end
+      t.verbose = true
+    end
+  end
+end
+
+# ----- Profiling -----
+
+if is_task?('profile')
+  temp_desc = <<END
+Run a profile of HAML.
+  TIMES=n sets the number of runs. Defaults to 100.
+  FILE=n sets the file to profile. Defaults to 'standard'.
+END
+  desc temp_desc.chomp
+  task :profile do
+    require 'test/profile'
+    
+    puts '-'*51, "Profiling Haml::Template", '-'*51
+    
+    args = []
+    args.push ENV['TIMES'].to_i if ENV['TIMES']
+    args.push ENV['FILE'] if ENV['FILE']
+    
+    profiler = Haml::Profiler.new
+    res = profiler.profile(*args)
+    puts res
+    
+    puts '-'*51
+  end
+end

data/VERSION

@@ -0,0 +1 @@
+1.0.0

data/bin/haml

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+# The command line Haml parser.
+
+if ARGV[0] == "--help" or ARGV[0] == "-h" or ARGV[0] == "-?"
+  puts <<END
+Usage: haml (template file) (output file)
+
+Description:
+  Uses the Haml engine to parse the specified template
+  and outputs the result to the specified file.
+END
+else
+  require File.join(File.dirname(__FILE__), '..', 'lib', 'haml', 'engine')
+
+  template = File.read(ARGV[0])
+  result = Haml::Engine.new(template).to_html
+  File.open(ARGV[1], "w") { |f| f.write(result) }
+end

data/lib/haml/buffer.rb

@@ -0,0 +1,224 @@
+module Haml
+  # This class is used only internally. It holds the buffer of XHTML that
+  # is eventually output by Haml::Engine's to_html method. It's called
+  # from within the precompiled code, and helps reduce the amount of
+  # processing done within instance_eval'd code.
+  class Buffer
+    include Haml::Helpers
+
+    # Set the maximum length for a line to be considered a one-liner.
+    # Lines <= the maximum will be rendered on one line,
+    # i.e. <tt><p>Hello world</p></tt>
+    ONE_LINER_LENGTH     = 50
+
+    # The string that holds the compiled XHTML. This is aliased as
+    # _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
+
+    # Creates a new buffer.
+    def initialize(options = {})
+      @options = options
+      @quote_escape = options[:attr_wrapper] == '"' ? "&quot;" : "&apos;"
+      @other_quote_char = options[:attr_wrapper] == '"' ? "'" : '"'
+      @buffer = ""
+      @one_liner_pending = false
+      @tabulation = 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)
+        @buffer << text
+      else
+        if @one_liner_pending
+          @buffer << "\n"
+          @one_liner_pending = false
+        end
+        @buffer << "#{tabs(tabulation)}#{text}\n"
+      end
+    end
+
+    # Properly formats the output of a script that was run in the
+    # instance_eval.
+    def push_script(result, tabulation, flattened)
+      if flattened
+        result = find_and_flatten(result)
+      end
+      unless result.nil?
+        result = result.to_s
+        while result[-1] == 10 # \n
+          # String#chomp is slow
+          result = result[0...-1]
+        end
+        
+        result = result.gsub("\n", "\n#{tabs(tabulation)}")
+        push_text result, tabulation
+      end
+      nil
+    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_object_ref(obj_ref)) if obj_ref
+      attributes.merge!(parse_class_and_id(class_id)) unless class_id.nil? || class_id.empty?
+      attributes.merge!(attributes_hash) if attributes_hash
+
+      @one_liner_pending = false
+      if atomic
+        str = " />\n"
+      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}"
+    end
+
+    # Creates a closing tag with the given name.
+    def close_tag(name, tabulation)
+      if @one_liner_pending
+        @buffer << "</#{name}>\n"
+        @one_liner_pending = false
+      else
+        push_text("</#{name}>", tabulation)
+      end
+    end
+
+    # Opens an XHTML comment.
+    def open_comment(try_one_line, conditional, tabulation)
+      conditional << ">" if conditional
+      @buffer << "#{tabs(tabulation)}<!--#{conditional.to_s} "
+      if try_one_line
+        @one_liner_pending = true
+      else
+        @buffer << "\n"
+      end
+    end
+
+    # Closes an XHTML comment.
+    def close_comment(has_conditional, tabulation)
+      close_tag = has_conditional ? "<![endif]-->" : "-->"
+      if @one_liner_pending
+        @buffer << " #{close_tag}\n"
+        @one_liner_pending = false
+      else
+        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)
+      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}", :class => class_name}
+    end
+
+    # Takes a hash and builds a list of XHTML attributes from it, returning
+    # the result.
+    def build_attributes(attributes = {})
+      result = attributes.collect do |a,v|
+        unless v.nil?
+          v = v.to_s
+          attr_wrapper = @options[:attr_wrapper]
+          if v.include? attr_wrapper
+            if v.include? @other_quote_char
+              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
+
+    # Returns whether or not the given value is short enough to be rendered
+    # on one line.
+    def one_liner?(value)
+      value.length <= ONE_LINER_LENGTH && value.scan(/\n/).empty?
+    end
+
+    # Isolates the whitespace-sensitive tags in the string and uses Haml::Helpers#flatten
+    # to convert any endlines inside them into html entities.
+    def find_and_flatten(input)
+      input = input.to_s
+      input.scan(/<(textarea|code|pre)[^>]*>(.*?)<\/\1>/im) do |tag, contents|
+        input = input.gsub(contents, Haml::Helpers.flatten(contents))
+      end
+      input
+    end
+  end
+end
+
+class String # :nodoc
+  alias_method :old_comp, :<=>
+  def <=>(other)
+    if other.is_a? NilClass
+      -1
+    else
+      old_comp(other)
+    end
+  end
+end
+
+class NilClass # :nodoc:
+  include Comparable
+  
+  def <=>(other)
+    other.nil? ? 0 : 1
+  end
+end
+

data/lib/haml/engine.rb

@@ -0,0 +1,551 @@
+require File.dirname(__FILE__) + '/helpers'
+require File.dirname(__FILE__) + '/buffer'
+
+module Haml
+  # This is the class where all the parsing and processing of the HAML
+  # template is done. It can be directly used by the user by creating a
+  # new instance and calling to_html to render the template. For example:
+  #
+  #   template = File.load('templates/really_cool_template.haml')
+  #   haml_engine = Haml::Engine.new(template)
+  #   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
+
+    # Designates an XHTML/XML element.
+    ELEMENT         = '%'[0]
+
+    # Designates a <tt><div></tt> element with the given class.
+    DIV_CLASS       = '.'[0]
+
+    # Designates a <tt><div></tt> element with the given id.
+    DIV_ID          = '#'[0]
+
+    # Designates an XHTML/XML comment.
+    COMMENT         = '/'[0]
+
+    # Designates an XHTML doctype.
+    DOCTYPE         = '!'[0]
+
+    # Designates script, the result of which is output.
+    SCRIPT          = '='[0]
+
+    # Designates script, the result of which is flattened and output.
+    FLAT_SCRIPT     = '~'[0]
+
+    # Designates script which is run but not output.
+    SILENT_SCRIPT   = '-'[0]
+
+    # When following SILENT_SCRIPT, designates a comment that is not output.
+    SILENT_COMMENT  = '#'[0]
+
+    # Designates a non-parsed line.
+    ESCAPE          = '\\'[0]
+
+    # Designates a non-parsed line. Not actually a character.
+    PLAIN_TEXT      = -1
+
+    # Keeps track of the ASCII values of the characters that begin a
+    # specially-interpreted line.
+    SPECIAL_CHARACTERS   = [
+      ELEMENT,
+      DIV_CLASS,
+      DIV_ID,
+      COMMENT,
+      DOCTYPE,
+      SCRIPT,
+      FLAT_SCRIPT,
+      SILENT_SCRIPT,
+      ESCAPE
+    ]
+
+    # The value of the character that designates that a line is part
+    # of a multiline string.
+    MULTILINE_CHAR_VALUE = '|'[0]
+
+    # Characters that designate that a multiline string may be about
+    # to begin.
+    MULTILINE_STARTERS   = SPECIAL_CHARACTERS - ["/"[0]]
+
+    # Keywords that appear in the middle of a Ruby block with lowered
+    # indentation. If a block has been started using indentation,
+    # lowering the indentation  with one of these won't end the block.
+    # For example:
+    #
+    #   - if foo
+    #     %p yes!
+    #   - else
+    #     %p no!
+    #
+    # The block is ended after <tt>%p no!</tt>, because <tt>else</tt>
+    # is a member of this array.
+    MID_BLOCK_KEYWORDS   = ['else', 'elsif', 'rescue', 'ensure', 'when']
+
+    # Creates a new instace of Haml::Engine that will compile the given
+    # template string when <tt>to_html</tt> is called.
+    # See REFERENCE for available options.
+    #
+    #--
+    # When adding options, remember to add information about them
+    # to REFERENCE!
+    #++
+    #
+    def initialize(template, options = {})
+      @options = {
+        :suppress_eval => false,
+        :attr_wrapper => "'",
+        :locals => {}
+      }.merge options
+      @precompiled = @options[:precompiled]
+
+      @template = template #String
+      @to_close_stack = []
+      @output_tabs = 0
+      @template_tabs = 0
+
+      # This is the base tabulation of the currently active
+      # flattened block. -1 signifies that there is no such block.
+      @flat_spaces = -1
+
+      # 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)
+    end
+
+    # Processes the template and returns the result as a string.
+    def to_html(scope = Object.new, &block)
+      @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
+      compile &block
+
+      # Return the result string
+      @buffer.buffer
+    end
+
+   private
+
+    #Precompile each line
+    def do_precompile
+      push_silent <<-END
+        def _haml_render
+        _hamlout = @haml_stack[-1]
+        _erbout = _hamlout.buffer
+      END
+      
+      old_line = nil
+      old_index = nil
+      old_spaces = nil
+      old_tabs = nil
+      (@template + "\n\n").each_with_index do |line, index|
+        spaces, tabs = count_soft_tabs(line)
+        line = line.strip
+        
+        if old_line
+          block_opened = tabs > old_tabs
+          
+          suppress_render = handle_multiline(old_tabs, old_line, old_index)
+          
+          if !suppress_render
+            line_empty = old_line.empty?
+            process_indent(old_tabs, old_line) unless line_empty
+            flat = @flat_spaces != -1
+
+            if flat
+              push_flat(old_line, old_spaces)
+            elsif !line_empty
+              process_line(old_line, old_index, block_opened)
+            end
+          end
+        end
+        
+        old_line = line
+        old_index = index
+        old_spaces = spaces
+        old_tabs = tabs
+      end
+
+      # Close all the open tags
+      @template_tabs.times { close }
+
+      push_silent "end"
+    end
+    
+    # Processes and deals with lowering indentation.
+    def process_indent(count, line)
+      if count <= @template_tabs && @template_tabs > 0
+        to_close = @template_tabs - count
+
+        to_close.times do |i|
+          offset = to_close - 1 - i
+          unless offset == 0 && mid_block_keyword?(line)
+            close
+          end
+        end
+      end
+    end
+
+    # Processes a single line of HAML.
+    #
+    # This method doesn't return anything; it simply processes the line and
+    # adds the appropriate code to <tt>@precompiled</tt>.
+    def process_line(line, index, block_opened)
+      case line[0]
+      when DIV_CLASS, DIV_ID
+        render_div(line, index)
+      when ELEMENT
+        render_tag(line, index)
+      when COMMENT
+        render_comment(line)
+      when SCRIPT
+        push_script(line[1..-1], false, block_opened, index)
+      when FLAT_SCRIPT
+        push_flat_script(line[1..-1], block_opened, index)
+      when SILENT_SCRIPT
+        sub_line = line[1..-1]
+        unless sub_line[0] == SILENT_COMMENT
+          push_silent(sub_line, index)
+          if block_opened && !mid_block_keyword?(line)
+            push_and_tabulate([:script])
+          end
+        end
+      when DOCTYPE
+        if line[0...3] == '!!!'
+          render_doctype(line)
+        else
+          push_text line
+        end
+      when ESCAPE
+        push_text line[1..-1]
+      else
+        push_text line
+      end
+    end
+    
+    # Returns whether or not the line is a silent script line with one
+    # of Ruby's mid-block keywords.
+    def mid_block_keyword?(line)
+      line.length > 2 && line[0] == SILENT_SCRIPT && MID_BLOCK_KEYWORDS.include?(line[1..-1].split[0])
+    end
+
+    # Deals with all the logic of figuring out whether a given line is
+    # the beginning, continuation, or end of a multiline sequence.
+    #
+    # This returns whether or not the line should be
+    # rendered normally.
+    def handle_multiline(count, line, index)
+      suppress_render = false
+      # Multilines are denoting by ending with a `|` (124)
+      if is_multiline?(line) && @multiline_buffer
+        # A multiline string is active, and is being continued
+        @multiline_buffer += line[0...-1]
+        suppress_render = true
+      elsif is_multiline?(line) && (MULTILINE_STARTERS.include? line[0])
+        # A multiline string has just been activated, start adding the lines
+        @multiline_buffer = line[0...-1]
+        @multiline_count = count
+        @multiline_index = index
+        process_indent(count, line)
+        suppress_render = true
+      elsif @multiline_buffer
+        # A multiline string has just ended, make line into the result
+        unless line.empty?
+          process_line(@multiline_buffer, @multiline_index, count > @multiline_count)
+          @multiline_buffer = nil
+        end
+      end
+
+      return suppress_render
+    end
+
+    # Checks whether or not +line+ is in a multiline sequence.
+    def is_multiline?(line)                                          # ' '[0] == 32
+      line && line.length > 1 && line[-1] == MULTILINE_CHAR_VALUE && line[-2] == 32
+    end
+
+    # Takes <tt>@precompiled</tt>, a string buffer of Ruby code, and
+    # evaluates it in the context of <tt>@scope_object</tt>, after preparing
+    # <tt>@scope_object</tt>. The code in <tt>@precompiled</tt> populates
+    # <tt>@buffer</tt> with the compiled XHTML code.
+    def compile(&block)
+      # Set the local variables pointing to the buffer
+      buffer = @buffer
+      @scope_object.extend Haml::Helpers
+      @scope_object.instance_eval do
+        @haml_stack ||= Array.new
+        @haml_stack.push(buffer)
+
+        class << self
+          attr :haml_lineno # :nodoc:
+        end
+      end
+
+      begin
+        # Evaluate the buffer in the context of the scope object
+        @scope_object.instance_eval @precompiled
+        @scope_object._haml_render &block
+      rescue Exception => e
+        # Get information from the exception and format it so that
+        # Rails can understand it.
+        compile_error = e.message.scan(/\(eval\):([0-9]*):in `[-_a-zA-Z]*': compile error/)[0]
+        filename = "(haml)"
+        if @scope_object.methods.include? "haml_filename"
+          # For some reason that I can't figure out,
+          # @scope_object.methods.include? "haml_filename" && @scope_object.haml_filename
+          # is false when it shouldn't be. Nested if statements work, though.
+
+          if @scope_object.haml_filename
+            filename = "#{@scope_object.haml_filename}.haml"
+          end
+        end
+        lineno = @scope_object.haml_lineno
+
+        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
+        end
+
+        e.backtrace.unshift "#{filename}:#{lineno}"
+        raise e
+      end
+
+      # Get rid of the current buffer
+      @scope_object.instance_eval do
+        @haml_stack.pop
+      end
+    end
+
+    # Evaluates <tt>text</tt> in the context of <tt>@scope_object</tt>, but
+    # does not output the result.
+    def push_silent(text, index = nil)
+      if index
+        @precompiled << "@haml_lineno = #{index + 1}\n#{text}\n"
+      else
+        # Not really DRY, but probably faster
+        @precompiled << "#{text}\n"
+      end
+    end
+
+    # Adds <tt>text</tt> to <tt>@buffer</tt> with appropriate tabulation
+    # without parsing it.
+    def push_text(text)
+      @precompiled << "_hamlout.push_text(#{text.dump}, #{@output_tabs})\n"
+    end
+
+    # Adds +text+ to <tt>@buffer</tt> while flattening text.
+    def push_flat(text, spaces)
+      tabulation = spaces - @flat_spaces
+      @precompiled << "_hamlout.push_text(#{text.dump}, #{tabulation > -1 ? tabulation : 0}, true)\n"
+    end
+
+    # Causes <tt>text</tt> to be evaluated in the context of
+    # <tt>@scope_object</tt> and the result to be added to <tt>@buffer</tt>.
+    #
+    # If <tt>flattened</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, block_opened, index)
+      unless options[:suppress_eval]
+        push_silent("haml_temp = #{text}", index)
+        out = "haml_temp = _hamlout.push_script(haml_temp, #{@output_tabs}, #{flattened})\n"
+        if block_opened
+          push_and_tabulate([:loud, out])
+        else
+          @precompiled << out
+        end
+      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, block_opened, index)
+      unless text.empty?
+        push_script(text, true, block_opened, index)
+      else
+        start_flat(false)
+      end
+    end
+
+    # Closes the most recent item in <tt>@to_close_stack</tt>.
+    def close
+      tag, value = @to_close_stack.pop
+      case tag
+      when :script
+        close_block
+      when :comment
+        close_comment value
+      when :element
+        close_tag value
+      when :flat
+        close_flat value
+      when :loud
+        close_loud value
+      end
+    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
+      @template_tabs -= 1
+      @precompiled << "_hamlout.close_tag(#{tag.dump}, #{@output_tabs})\n"
+    end
+
+    # Closes a Ruby block.
+    def close_block
+      push_silent "end"
+      @template_tabs -= 1
+    end
+
+    # Closes a comment.
+    def close_comment(has_conditional)
+      @output_tabs -= 1
+      @template_tabs -= 1
+      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"
+      @precompiled << command
+      @template_tabs -= 1
+    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, index)
+      line.scan(/[%]([-:_a-zA-Z0-9]+)([-_a-zA-Z0-9\.\#]*)(\{.*\})?(\[.*\])?([=\/\~]?)?(.*)?/) do |tag_name, attributes, attributes_hash, object_ref, action, value|
+        value = value.to_s
+
+        case action
+        when '/'
+          atomic = true
+        when '=', '~'
+          parse = true
+        else
+          value = value.strip
+        end
+
+        flattened = (action == '~')
+        value_exists = !value.empty?
+        attributes_hash = "nil" unless attributes_hash
+        object_ref = "nil" unless object_ref
+
+        push_silent "_hamlout.open_tag(#{tag_name.inspect}, #{@output_tabs}, #{atomic.inspect}, #{value_exists.inspect}, #{attributes.inspect}, #{attributes_hash}, #{object_ref}, #{flattened.inspect})"
+
+        unless atomic
+          push_and_tabulate([:element, tag_name])
+          @output_tabs += 1
+
+          if value_exists
+            if parse
+              push_script(value, flattened, false, index)
+            else
+              push_text(value)
+            end
+            close
+          elsif flattened
+            start_flat(true)
+          end
+        end
+      end
+    end
+
+    # Renders a line that creates an XHTML tag and has an implicit div because of
+    # <tt>.</tt> or <tt>#</tt>.
+    def render_div(line, index)
+      render_tag('%div' + line, index)
+    end
+
+    # Renders an XHTML comment.
+    def render_comment(line)
+      conditional, content = line.scan(/\/(\[[a-zA-Z0-9 \.]*\])?(.*)/)[0]
+      content = content.strip
+      try_one_line = !content.empty?
+      push_silent "_hamlout.open_comment(#{try_one_line}, #{conditional.inspect}, #{@output_tabs})"
+      @output_tabs += 1
+      push_and_tabulate([:comment, !conditional.nil?])
+      if try_one_line
+        push_text content
+        close
+      end
+    end
+    
+    # Renders an XHTML doctype or XML shebang.
+    def render_doctype(line)
+      line = line[3..-1].lstrip.downcase
+      if line[0...3] == "xml"
+        encoding = line.split[1] || "utf-8"
+        wrapper = @options[:attr_wrapper]
+        doctype = "<?xml version=#{wrapper}1.0#{wrapper} encoding=#{wrapper}#{encoding}#{wrapper} ?>"
+      else
+        version, type = line.scan(/([0-9]\.[0-9])?[\s]*([a-zA-Z]*)/)[0]
+        if version == "1.1"
+          doctype = '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">'
+        else
+          case type
+          when "strict"
+            doctype = '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">'
+          when "frameset"
+            doctype = '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Frameset//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd">'
+          else
+            doctype = '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">'
+          end
+        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
+
+    # Counts the tabulation of a line.
+    def count_soft_tabs(line)
+      spaces = line.index(/[^ ]/)
+      spaces ? [spaces, spaces/2] : []
+    end
+    
+    # Pushes value onto <tt>@to_close_stack</tt> and increases
+    # <tt>@template_tabs</tt>.
+    def push_and_tabulate(value)
+      @to_close_stack.push(value)
+      @template_tabs += 1
+    end
+  end
+end