html2haml 1.0.0.beta.1

data/.gitignore

@@ -0,0 +1,10 @@
+/.yardoc
+/coverage
+/doc
+/pkg
+*.rbc
+.rbenv-version
+Gemfile.lock
+.rvmrc
+.rbx
+tmp

data/.travis.yml

@@ -0,0 +1,14 @@
+rvm:
+  - 1.8.7
+  - 1.9.3
+  - jruby-18mode
+  - rbx-18mode
+
+gemfile:
+  - Gemfile
+
+branches:
+  only:
+    - master
+
+script: "bundle exec rake test"

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+gemspec
+

data/MIT-LICENSE

@@ -0,0 +1,18 @@
+Copyright (c) 2006-2012 Hampton Catlin, Nathan Weizenbaum and Norman Clarke
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,40 @@
+# Html2haml
+
+Converts HTML to Haml. This is in the process of being extracted from the Haml 
+gem.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'html2haml'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install html2haml
+
+## Usage
+
+See `html2haml --help`:
+
+    Usage: html2haml [options] [INPUT] [OUTPUT]
+
+    Description: Transforms an HTML file into corresponding Haml code.
+
+    Options:
+        -e, --erb                        Parse ERb tags.
+            --no-erb                     Don't parse ERb tags.
+        -r, --rhtml                      Deprecated; same as --erb.
+            --no-rhtml                   Deprecated; same as --no-erb.
+        -x, --xhtml                      Parse the input using the more strict XHTML parser.
+            --html-attributes            Use HTML style attributes instead of Ruby hash style.
+        -E ex[:in]                       Specify the default external and internal character encodings.
+        -s, --stdin                      Read input from standard input instead of an input file
+            --trace                      Show a full traceback on error
+            --unix-newlines              Use Unix-style newlines in written files.
+        -?, -h, --help                   Show this message
+        -v, --version                    Print version

data/Rakefile

@@ -0,0 +1,25 @@
+require "rake/clean"
+require "rake/testtask"
+require "rubygems/package_task"
+
+task :default => :test
+
+CLEAN.replace %w(pkg doc coverage .yardoc)
+
+Rake::TestTask.new do |t|
+  t.libs << 'lib' << 'test'
+  t.test_files = Dir["test/**/*_test.rb"]
+  t.verbose = true
+end
+
+task :set_coverage_env do
+  ENV["COVERAGE"] = "true"
+end
+
+desc "Run Simplecov (only works on 1.9)"
+task :coverage => [:set_coverage_env, :test]
+
+gemspec = File.expand_path("../html2haml.gemspec", __FILE__)
+if File.exist? gemspec
+  Gem::PackageTask.new(eval(File.read(gemspec))) { |pkg| }
+end

data/bin/html2haml

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

data/html2haml.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/html2haml/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Norman Clarke"]
+  gem.email         = ["norman@njclarke.com"]
+  gem.description   = %q{Converts HTML into Haml}
+  gem.summary       = %q{Converts HTML into Haml}
+  gem.homepage      = "http://haml.info"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "html2haml"
+  gem.require_paths = ["lib"]
+  gem.version       = Html2haml::VERSION
+
+  gem.add_dependency 'hpricot'
+  gem.add_dependency 'haml', '>= 3.2.0.beta.1'
+  gem.add_development_dependency 'erubis'
+  gem.add_development_dependency 'ruby_parser'
+  gem.add_development_dependency 'simplecov'
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'minitest'
+end

data/lib/html2haml.rb

@@ -0,0 +1,8 @@
+require "html2haml/version"
+require "haml/util"
+require "haml/parser"
+require "haml/error"
+require "html2haml/html"
+
+module Html2haml
+end

data/lib/html2haml/exec.rb

@@ -0,0 +1,260 @@
+require 'optparse'
+require 'fileutils'
+require 'rbconfig'
+
+module Html2haml
+  # This module handles the various Haml executables (`haml` and `haml-convert`).
+  module Exec
+    # An abstract class that encapsulates the executable code for all three executables.
+    class Generic
+      # @param args [Array<String>] The command-line arguments
+      def initialize(args)
+        @args = args
+        @options = {:for_engine => {}}
+      end
+
+      # Parses the command-line arguments and runs the executable.
+      # Calls `Kernel#exit` at the end, so it never returns.
+      #
+      # @see #parse
+      def parse!
+        begin
+          parse
+        rescue Exception => e
+          raise e if @options[:trace] || e.is_a?(SystemExit)
+
+          $stderr.print "#{e.class}: " unless e.class == RuntimeError
+          $stderr.puts "#{e.message}"
+          $stderr.puts "  Use --trace for backtrace."
+          exit 1
+        end
+        exit 0
+      end
+
+      # Parses the command-line arguments and runs the executable.
+      # This does not handle exceptions or exit the program.
+      #
+      # @see #parse!
+      def parse
+        @opts = OptionParser.new(&method(:set_opts))
+        @opts.parse!(@args)
+
+        process_result
+
+        @options
+      end
+
+      # @return [String] A description of the executable
+      def to_s
+        @opts.to_s
+      end
+
+      protected
+
+      # Finds the line of the source template
+      # on which an exception was raised.
+      #
+      # @param exception [Exception] The exception
+      # @return [String] The line number
+      def get_line(exception)
+        # SyntaxErrors have weird line reporting
+        # when there's trailing whitespace,
+        # which there is for Haml documents.
+        return (exception.message.scan(/:(\d+)/).first || ["??"]).first if exception.is_a?(::SyntaxError)
+        (exception.backtrace[0].scan(/:(\d+)/).first || ["??"]).first
+      end
+
+      # Tells optparse how to parse the arguments
+      # available for all executables.
+      #
+      # This is meant to be overridden by subclasses
+      # so they can add their own options.
+      #
+      # @param opts [OptionParser]
+      def set_opts(opts)
+        opts.on('-s', '--stdin', :NONE, 'Read input from standard input instead of an input file') do
+          @options[:input] = $stdin
+        end
+
+        opts.on('--trace', :NONE, 'Show a full traceback on error') do
+          @options[:trace] = true
+        end
+
+        opts.on('--unix-newlines', 'Use Unix-style newlines in written files.') do
+          # Note that this is the preferred way to check for Windows, since
+          # JRuby and Rubinius also run there.
+          if RbConfig::CONFIG['host_os'] =~ /mswin|windows|mingw/i
+            @options[:unix_newlines] = true
+          end
+        end
+
+        opts.on_tail("-?", "-h", "--help", "Show this message") do
+          puts opts
+          exit
+        end
+
+        opts.on_tail("-v", "--version", "Print version") do
+          puts("html2haml #{::Html2haml::VERSION}")
+          exit
+        end
+      end
+
+      # Processes the options set by the command-line arguments.
+      # In particular, sets `@options[:input]` and `@options[:output]`
+      # to appropriate IO streams.
+      #
+      # This is meant to be overridden by subclasses
+      # so they can run their respective programs.
+      def process_result
+        input, output = @options[:input], @options[:output]
+        args = @args.dup
+        input ||=
+          begin
+            filename = args.shift
+            @options[:filename] = filename
+            open_file(filename) || $stdin
+          end
+        output ||= open_file(args.shift, 'w') || $stdout
+
+        @options[:input], @options[:output] = input, output
+      end
+
+      COLORS = { :red => 31, :green => 32, :yellow => 33 }
+
+      # Prints a status message about performing the given action,
+      # colored using the given color (via terminal escapes) if possible.
+      #
+      # @param name [#to_s] A short name for the action being performed.
+      #   Shouldn't be longer than 11 characters.
+      # @param color [Symbol] The name of the color to use for this action.
+      #   Can be `:red`, `:green`, or `:yellow`.
+      def puts_action(name, color, arg)
+        return if @options[:for_engine][:quiet]
+        printf color(color, "%11s %s\n"), name, arg
+      end
+
+      # Same as `Kernel.puts`, but doesn't print anything if the `--quiet` option is set.
+      #
+      # @param args [Array] Passed on to `Kernel.puts`
+      def puts(*args)
+        return if @options[:for_engine][:quiet]
+        Kernel.puts(*args)
+      end
+
+      # Wraps the given string in terminal escapes
+      # causing it to have the given color.
+      # If terminal esapes aren't supported on this platform,
+      # just returns the string instead.
+      #
+      # @param color [Symbol] The name of the color to use.
+      #   Can be `:red`, `:green`, or `:yellow`.
+      # @param str [String] The string to wrap in the given color.
+      # @return [String] The wrapped string.
+      def color(color, str)
+        raise "[BUG] Unrecognized color #{color}" unless COLORS[color]
+
+        # Almost any real Unix terminal will support color,
+        # so we just filter for Windows terms (which don't set TERM)
+        # and not-real terminals, which aren't ttys.
+        return str if ENV["TERM"].nil? || ENV["TERM"].empty? || !STDOUT.tty?
+        return "\e[#{COLORS[color]}m#{str}\e[0m"
+      end
+
+      private
+
+      def open_file(filename, flag = 'r')
+        return if filename.nil?
+        flag = 'wb' if @options[:unix_newlines] && flag == 'w'
+        File.open(filename, flag)
+      end
+
+      def handle_load_error(err)
+        dep = err.message[/^no such file to load -- (.*)/, 1]
+        raise err if @options[:trace] || dep.nil? || dep.empty?
+        $stderr.puts <<MESSAGE
+Required dependency #{dep} not found!
+    Run "gem install #{dep}" to get it.
+  Use --trace for backtrace.
+MESSAGE
+        exit 1
+      end
+    end
+
+    # The `html2haml` executable.
+    class HTML2Haml < Generic
+      # @param args [Array<String>] The command-line arguments
+      def initialize(args)
+        super
+        @module_opts = {}
+      end
+
+      # Tells optparse how to parse the arguments.
+      #
+      # @param opts [OptionParser]
+      def set_opts(opts)
+        opts.banner = <<END
+Usage: html2haml [options] [INPUT] [OUTPUT]
+
+Description: Transforms an HTML file into corresponding Haml code.
+
+Options:
+END
+
+        opts.on('-e', '--erb', 'Parse ERb tags.') do
+          @module_opts[:erb] = true
+        end
+
+        opts.on('--no-erb', "Don't parse ERb tags.") do
+          @options[:no_erb] = true
+        end
+
+        opts.on('-r', '--rhtml', 'Deprecated; same as --erb.') do
+          @module_opts[:erb] = true
+        end
+
+        opts.on('--no-rhtml', "Deprecated; same as --no-erb.") do
+          @options[:no_erb] = true
+        end
+
+        opts.on('-x', '--xhtml', 'Parse the input using the more strict XHTML parser.') do
+          @module_opts[:xhtml] = true
+        end
+
+        opts.on("--html-attributes", "Use HTML style attributes instead of Ruby hash style.") do
+          @module_opts[:html_style_attributes] = true
+        end
+
+        unless RUBY_VERSION < "1.9"
+          opts.on('-E ex[:in]', 'Specify the default external and internal character encodings.') do |encoding|
+            external, internal = encoding.split(':')
+            Encoding.default_external = external if external && !external.empty?
+            Encoding.default_internal = internal if internal && !internal.empty?
+          end
+        end
+
+        super
+      end
+
+      # Processes the options set by the command-line arguments,
+      # and runs the HTML compiler appropriately.
+      def process_result
+        super
+
+        require 'html2haml/html'
+
+        input = @options[:input]
+        output = @options[:output]
+
+        @module_opts[:erb] ||= input.respond_to?(:path) && input.path =~ /\.(rhtml|erb)$/
+        @module_opts[:erb] &&= @options[:no_erb] != false
+
+        output.write(::Haml::HTML.new(input, @module_opts).render)
+      rescue ::Haml::Error => e
+        raise "#{e.is_a?(::Haml::SyntaxError) ? "Syntax error" : "Error"} on line " +
+          "#{get_line e}: #{e.message}"
+      rescue LoadError => err
+        handle_load_error(err)
+      end
+    end
+  end
+end

data/lib/html2haml/html.rb

@@ -0,0 +1,423 @@
+require 'rubygems'
+require 'cgi'
+require 'hpricot'
+require 'html2haml/html/erb'
+
+# Haml monkeypatches various Hpricot classes
+# to add methods for conversion to Haml.
+# @private
+module Hpricot
+  # @see Hpricot
+  module Node
+    # Whether this node has already been converted to Haml.
+    # Only used for text nodes and elements.
+    #
+    # @return [Boolean]
+    attr_accessor :converted_to_haml
+
+    # Returns the Haml representation of the given node.
+    #
+    # @param tabs [Fixnum] The indentation level of the resulting Haml.
+    # @option options (see Haml::HTML#initialize)
+    def to_haml(tabs, options)
+      return "" if converted_to_haml || to_s.strip.empty?
+      text = uninterp(self.to_s)
+      node = next_node
+      while node.is_a?(::Hpricot::Elem) && node.name == "haml:loud"
+        node.converted_to_haml = true
+        text << '#{' <<
+          CGI.unescapeHTML(node.inner_text).gsub(/\n\s*/, ' ').strip << '}'
+
+        if node.next_node.is_a?(::Hpricot::Text)
+          node = node.next_node
+          text << uninterp(node.to_s)
+          node.converted_to_haml = true
+        end
+
+        node = node.next_node
+      end
+      return parse_text_with_interpolation(text, tabs)
+    end
+
+    private
+
+    def erb_to_interpolation(text, options)
+      return text unless options[:erb]
+      text = CGI.escapeHTML(uninterp(text))
+      %w[<haml:loud> </haml:loud>].each {|str| text.gsub!(CGI.escapeHTML(str), str)}
+      ::Hpricot::XML(text).children.inject("") do |str, elem|
+        if elem.is_a?(::Hpricot::Text)
+          str + CGI.unescapeHTML(elem.to_s)
+        else # <haml:loud> element
+          str + '#{' + CGI.unescapeHTML(elem.innerText.strip) + '}'
+        end
+      end
+    end
+
+    def tabulate(tabs)
+      '  ' * tabs
+    end
+
+    def uninterp(text)
+      text.gsub('#{', '\#{') #'
+    end
+
+    def attr_hash
+      attributes.to_hash
+    end
+
+    def parse_text(text, tabs)
+      parse_text_with_interpolation(uninterp(text), tabs)
+    end
+
+    def parse_text_with_interpolation(text, tabs)
+      text.strip!
+      return "" if text.empty?
+
+      text.split("\n").map do |line|
+        line.strip!
+        "#{tabulate(tabs)}#{'\\' if Haml::Parser::SPECIAL_CHARACTERS.include?(line[0])}#{line}\n"
+      end.join
+    end
+  end
+end
+
+# @private
+HAML_TAGS = %w[haml:block haml:loud haml:silent]
+
+HAML_TAGS.each do |t|
+  Hpricot::ElementContent[t] = {}
+  Hpricot::ElementContent.keys.each do |key|
+    Hpricot::ElementContent[t][key.hash] = true
+  end
+end
+
+Hpricot::ElementContent.keys.each do |k|
+  HAML_TAGS.each do |el|
+    val = Hpricot::ElementContent[k]
+    val[el.hash] = true if val.is_a?(Hash)
+  end
+end
+
+module Haml
+  # Converts HTML documents into Haml templates.
+  # Depends on [Hpricot](http://github.com/whymirror/hpricot) for HTML parsing.
+  # If ERB conversion is being used, also depends on 
+  # [Erubis](http://www.kuwata-lab.com/erubis) to parse the ERB
+  # and [ruby_parser](http://parsetree.rubyforge.org/) to parse the Ruby code.
+  #
+  # Example usage:
+  #
+  #     Haml::HTML.new("<a href='http://google.com'>Blat</a>").render
+  #       #=> "%a{:href => 'http://google.com'} Blat"
+  class HTML
+    # @param template [String, Hpricot::Node] The HTML template to convert
+    # @option options :erb [Boolean] (false) Whether or not to parse
+    #   ERB's `<%= %>` and `<% %>` into Haml's `=` and `-`
+    # @option options :xhtml [Boolean] (false) Whether or not to parse
+    #   the HTML strictly as XHTML
+    def initialize(template, options = {})
+      @options = options
+
+      if template.is_a? Hpricot::Node
+        @template = template
+      else
+        if template.is_a? IO
+          template = template.read
+        end
+
+        template = Haml::Util.check_encoding(template) {|msg, line| raise Haml::Error.new(msg, line)}
+
+        if @options[:erb]
+          require 'html2haml/html/erb'
+          template = ERB.compile(template)
+        end
+
+        method = @options[:xhtml] ? Hpricot.method(:XML) : method(:Hpricot)
+        @template = method.call(template.gsub('&', '&amp;'))
+      end
+    end
+
+    # Processes the document and returns the result as a string
+    # containing the Haml template.
+    def render
+      @template.to_haml(0, @options)
+    end
+    alias_method :to_haml, :render
+
+    TEXT_REGEXP = /^(\s*).*$/
+
+    # @see Hpricot
+    # @private
+    class ::Hpricot::Doc
+      # @see Haml::HTML::Node#to_haml
+      def to_haml(tabs, options)
+        (children || []).inject('') {|s, c| s << c.to_haml(0, options)}
+      end
+    end
+
+    # @see Hpricot
+    # @private
+    class ::Hpricot::XMLDecl
+      # @see Haml::HTML::Node#to_haml
+      def to_haml(tabs, options)
+        "#{tabulate(tabs)}!!! XML\n"
+      end
+    end
+
+    # @see Hpricot
+    # @private
+    class ::Hpricot::CData
+      # @see Haml::HTML::Node#to_haml
+      def to_haml(tabs, options)
+        content = parse_text_with_interpolation(
+          erb_to_interpolation(self.content, options), tabs + 1)
+        "#{tabulate(tabs)}:cdata\n#{content}"
+      end
+    end
+
+    # @see Hpricot
+    # @private
+    class ::Hpricot::DocType
+      # @see Haml::HTML::Node#to_haml
+      def to_haml(tabs, options)
+        attrs = public_id.nil? ? ["", "", ""] :
+          public_id.scan(/DTD\s+([^\s]+)\s*([^\s]*)\s*([^\s]*)\s*\/\//)[0]
+        raise Haml::SyntaxError.new("Invalid doctype") if attrs == nil
+
+        type, version, strictness = attrs.map { |a| a.downcase }
+        if type == "html"
+          version = ""
+          strictness = "strict" if strictness == ""
+        end
+
+        if version == "1.0" || version.empty?
+          version = nil
+        end
+
+        if strictness == 'transitional' || strictness.empty?
+          strictness = nil
+        end
+
+        version = " #{version.capitalize}" if version
+        strictness = " #{strictness.capitalize}" if strictness
+
+        "#{tabulate(tabs)}!!!#{version}#{strictness}\n"
+      end
+    end
+
+    # @see Hpricot
+    # @private
+    class ::Hpricot::Comment
+      # @see Haml::HTML::Node#to_haml
+      def to_haml(tabs, options)
+        content = self.content
+        if content =~ /\A(\[[^\]]+\])>(.*)<!\[endif\]\z/m
+          condition = $1
+          content = $2
+        end
+
+        if content.include?("\n")
+          "#{tabulate(tabs)}/#{condition}\n#{parse_text(content, tabs + 1)}"
+        else
+          "#{tabulate(tabs)}/#{condition} #{content.strip}\n"
+        end
+      end
+    end
+
+    # @see Hpricot
+    # @private
+    class ::Hpricot::Elem
+      # @see Haml::HTML::Node#to_haml
+      def to_haml(tabs, options)
+        return "" if converted_to_haml
+        if name == "script" &&
+            (attr_hash['type'].nil? || attr_hash['type'] == "text/javascript") &&
+            (attr_hash.keys - ['type']).empty?
+          return to_haml_filter(:javascript, tabs, options)
+        elsif name == "style" &&
+            (attr_hash['type'].nil? || attr_hash['type'] == "text/css") &&
+            (attr_hash.keys - ['type']).empty?
+          return to_haml_filter(:css, tabs, options)
+        end
+
+        output = tabulate(tabs)
+        if options[:erb] && name[0...5] == 'haml:'
+          case name[5..-1]
+          when "loud"
+            lines = CGI.unescapeHTML(inner_text).split("\n").
+              map {|s| s.rstrip}.reject {|s| s.strip.empty?}
+            lines.first.gsub!(/^[ \t]*/, "= ")
+
+            if lines.size > 1 # Multiline script block
+              # Normalize the indentation so that the last line is the base
+              indent_str = lines.last[/^[ \t]*/]
+              indent_re = /^[ \t]{0,#{indent_str.count(" ") + 8 * indent_str.count("\t")}}/
+              lines.map! {|s| s.gsub!(indent_re, '')}
+
+              # Add an extra "  " to make it indented relative to "= "
+              lines[1..-1].each {|s| s.gsub!(/^/, "  ")}
+
+              # Add | at the end, properly aligned
+              length = lines.map {|s| s.size}.max + 1
+              lines.map! {|s| "%#{-length}s|" % s}
+
+              if next_sibling && next_sibling.is_a?(Hpricot::Elem) && next_sibling.name == "haml:loud" &&
+                  next_sibling.inner_text.split("\n").reject {|s| s.strip.empty?}.size > 1
+                lines << "-#"
+              end
+            end
+            return lines.map {|s| output + s + "\n"}.join
+          when "silent"
+            return CGI.unescapeHTML(inner_text).split("\n").map do |line|
+              next "" if line.strip.empty?
+              "#{output}- #{line.strip}\n"
+            end.join
+          when "block"
+            return render_children("", tabs, options)
+          end
+        end
+
+        if self.next && self.next.text? && self.next.content =~ /\A[^\s]/
+          if self.previous.nil? || self.previous.text? &&
+              (self.previous.content =~ /[^\s]\Z/ ||
+               self.previous.content =~ /\A\s*\Z/ && self.previous.previous.nil?)
+            nuke_outer_whitespace = true
+          else
+            output << "= succeed #{self.next.content.slice!(/\A[^\s]+/).dump} do\n"
+            tabs += 1
+            output << tabulate(tabs)
+          end
+        end
+
+        output << "%#{name}" unless name == 'div' &&
+          (static_id?(options) ||
+           static_classname?(options) &&
+           attr_hash['class'].split(' ').any?(&method(:haml_css_attr?)))
+
+        if attr_hash
+          if static_id?(options)
+            output << "##{attr_hash['id']}"
+            remove_attribute('id')
+          end
+          if static_classname?(options)
+            leftover = attr_hash['class'].split(' ').reject do |c|
+              next unless haml_css_attr?(c)
+              output << ".#{c}"
+            end
+            remove_attribute('class')
+            set_attribute('class', leftover.join(' ')) unless leftover.empty?
+          end
+          output << haml_attributes(options) if attr_hash.length > 0
+        end
+
+        output << ">" if nuke_outer_whitespace
+        output << "/" if empty? && !etag
+
+        if children && children.size == 1
+          child = children.first
+          if child.is_a?(::Hpricot::Text)
+            if !child.to_s.include?("\n")
+              text = child.to_haml(tabs + 1, options)
+              return output + " " + text.lstrip.gsub(/^\\/, '') unless text.chomp.include?("\n")
+              return output + "\n" + text
+            elsif ["pre", "textarea"].include?(name) ||
+                (name == "code" && parent.is_a?(::Hpricot::Elem) && parent.name == "pre")
+              return output + "\n#{tabulate(tabs + 1)}:preserve\n" +
+                innerText.gsub(/^/, tabulate(tabs + 2))
+            end
+          elsif child.is_a?(::Hpricot::Elem) && child.name == "haml:loud"
+            return output + child.to_haml(tabs + 1, options).lstrip
+          end
+        end
+
+        render_children(output + "\n", tabs, options)
+      end
+
+      private
+
+      def render_children(so_far, tabs, options)
+        (self.children || []).inject(so_far) do |output, child|
+          output + child.to_haml(tabs + 1, options)
+        end
+      end
+
+      def dynamic_attributes
+        @dynamic_attributes ||= begin
+          Hash[attr_hash.map do |name, value|
+            next if value.empty?
+            full_match = nil
+            ruby_value = value.gsub(%r{<haml:loud>\s*(.+?)\s*</haml:loud>}) do
+              full_match = $`.empty? && $'.empty?
+              CGI.unescapeHTML(full_match ? $1: "\#{#{$1}}")
+            end
+            next if ruby_value == value
+            [name, full_match ? ruby_value : %("#{ruby_value}")]
+          end]
+        end
+      end
+
+      def to_haml_filter(filter, tabs, options)
+        content =
+          if children.first.is_a?(::Hpricot::CData)
+            children.first.content
+          else
+            CGI.unescapeHTML(self.innerText)
+          end
+
+        content = erb_to_interpolation(content, options)
+        content.gsub!(/\A\s*\n(\s*)/, '\1')
+        original_indent = content[/\A(\s*)/, 1]
+        if content.split("\n").all? {|l| l.strip.empty? || l =~ /^#{original_indent}/}
+          content.gsub!(/^#{original_indent}/, tabulate(tabs + 1))
+        end
+
+        "#{tabulate(tabs)}:#{filter}\n#{content}"
+      end
+
+      def static_attribute?(name, options)
+        attr_hash[name] && !dynamic_attribute?(name, options)
+      end
+
+      def dynamic_attribute?(name, options)
+        options[:erb] and dynamic_attributes.key?(name)
+      end
+
+      def static_id?(options)
+        static_attribute?('id', options) && haml_css_attr?(attr_hash['id'])
+      end
+
+      def static_classname?(options)
+        static_attribute?('class', options)
+      end
+
+      def haml_css_attr?(attr)
+        attr =~ /^[-:\w]+$/
+      end
+
+      # Returns a string representation of an attributes hash
+      # that's prettier than that produced by Hash#inspect
+      def haml_attributes(options)
+        attrs = attr_hash.sort.map do |name, value|
+          haml_attribute_pair(name, value, options)
+        end
+        if options[:html_style_attributes]
+          "(#{attrs.join(' ')})"
+        else
+          "{#{attrs.join(', ')}}"
+        end
+      end
+
+      # Returns the string representation of a single attribute key value pair
+      def haml_attribute_pair(name, value, options)
+        value = dynamic_attribute?(name, options) ? dynamic_attributes[name] : value.inspect
+        if options[:html_style_attributes]
+          "#{name}=#{value}"
+        else
+          name = name.index(/\W/) ? name.inspect : ":#{name}"
+          "#{name} => #{value}"
+        end
+      end
+    end
+  end
+end