radiantcms-couchrest_model 0.1.3 → 0.1.4

data/vendor/plugins/haml/lib/haml/filters.rb

@@ -210,23 +210,6 @@ END
       end
     end
 
-    # Surrounds the filtered text with `<style>` and CDATA tags.
-    # Useful for including inline CSS.
-    module Css
-      include Base
-
-      # @see Base#render_with_options
-      def render_with_options(text, options)
-        <<END
-<style type=#{options[:attr_wrapper]}text/css#{options[:attr_wrapper]}>
-  /*<![CDATA[*/
-    #{text.rstrip.gsub("\n", "\n    ")}
-  /*]]>*/
-</style>
-END
-      end
-    end
-
     # Surrounds the filtered text with CDATA tags.
     module Cdata
       include Base
@@ -298,7 +281,7 @@ END
       end
     end
 
-    # Parses the filtered text with ERB.
+    # Parses the filtered text with ERB, like an RHTML template.
     # Not available if the {file:HAML_REFERENCE.md#suppress_eval-option `:suppress_eval`} option is set to true.
     # Embedded Ruby code is evaluated in the same context as the Haml template.
     module ERB
@@ -327,7 +310,6 @@ END
     end
     # An alias for the Textile filter,
     # since the only available Textile parser is RedCloth.
-    # @api public
     RedCloth = Textile
     Filters.defined['redcloth'] = RedCloth
 

data/vendor/plugins/haml/lib/haml/helpers.rb

@@ -342,9 +342,7 @@ MESSAGE
         haml_buffer.capture_position = position
         block.call(*args)
 
-        captured = haml_buffer.buffer.slice!(position..-1)
-        return captured if haml_buffer.options[:ugly]
-        captured = captured.split(/^/)
+        captured = haml_buffer.buffer.slice!(position..-1).split(/^/)
 
         min_tabs = nil
         captured.each do |line|
@@ -361,16 +359,22 @@ MESSAGE
       haml_buffer.capture_position = nil
     end
 
+    # @deprecated This will be removed in version 3.0.
+    # @see #haml_concat
+    def puts(*args)
+      warn <<END
+DEPRECATION WARNING:
+The Haml #puts helper is deprecated and will be removed in version 3.0.
+Use the #haml_concat helper instead.
+END
+      haml_concat(*args)
+    end
+
     # Outputs text directly to the Haml buffer, with the proper indentation.
     #
     # @param text [#to_s] The text to output
     def haml_concat(text = "")
-      unless haml_buffer.options[:ugly] || haml_indent == 0
-        haml_buffer.buffer << haml_indent <<
-          text.to_s.gsub("\n", "\n" + haml_indent) << "\n"
-      else
-        haml_buffer.buffer << text.to_s << "\n"
-      end
+      haml_buffer.buffer << haml_indent << text.to_s << "\n"
       ErrorReturn.new("haml_concat")
     end
 
@@ -384,11 +388,6 @@ MESSAGE
     # If the block is a Haml block or outputs text using \{#haml\_concat},
     # the text will be properly indented.
     #
-    # `name` can be a string using the standard Haml class/id shorthand
-    # (e.g. "span#foo.bar", "#foo").
-    # Just like standard Haml tags, these class and id values
-    # will be merged with manually-specified attributes.
-    #
     # `flags` is a list of symbol flags
     # like those that can be put at the end of a Haml tag
     # (`:/`, `:<`, and `:>`).
@@ -403,7 +402,7 @@ MESSAGE
     #
     #     haml_tag :table do
     #       haml_tag :tr do
-    #         haml_tag 'td.cell' do
+    #         haml_tag :td, {:class => 'cell'} do
     #           haml_tag :strong, "strong!"
     #           haml_concat "data"
     #         end
@@ -439,15 +438,13 @@ MESSAGE
     def haml_tag(name, *rest, &block)
       ret = ErrorReturn.new("haml_tag")
 
+      name = name.to_s
       text = rest.shift.to_s unless [Symbol, Hash, NilClass].any? {|t| rest.first.is_a? t}
       flags = []
       flags << rest.shift while rest.first.is_a? Symbol
-      attrs = Haml::Util.map_keys(rest.shift || {}) {|key| key.to_s}
-      name, attrs = merge_name_and_attributes(name.to_s, attrs)
-
       attributes = Haml::Precompiler.build_attributes(haml_buffer.html?,
                                                       haml_buffer.options[:attr_wrapper],
-                                                      attrs)
+                                                      rest.shift || {})
 
       if text.nil? && block.nil? && (haml_buffer.options[:autoclose].include?(name) || flags.include?(:/))
         haml_concat "<#{name}#{attributes} />"
@@ -461,17 +458,8 @@ MESSAGE
 
       tag = "<#{name}#{attributes}>"
       if block.nil?
-        text = text.to_s
-        if text.include?("\n")
-          haml_concat tag
-          tab_up
-          haml_concat text
-          tab_down
-          haml_concat "</#{name}>"
-        else
-          tag << text << "</#{name}>"
-          haml_concat tag
-        end
+        tag << text.to_s << "</#{name}>"
+        haml_concat tag
         return ret
       end
 
@@ -495,6 +483,7 @@ MESSAGE
     end
 
     # Characters that need to be escaped to HTML entities from user input
+    # @private
     HTML_ESCAPE = { '&'=>'&amp;', '<'=>'&lt;', '>'=>'&gt;', '"'=>'&quot;', "'"=>'&#039;', }
 
     # Returns a copy of `text` with ampersands, angle brackets and quotes
@@ -545,16 +534,6 @@ MESSAGE
 
     private
 
-    # Parses the tag name used for \{#haml\_tag}
-    # and merges it with the Ruby attributes hash.
-    def merge_name_and_attributes(name, attributes_hash = {})
-      # skip merging if no ids or classes found in name
-      return name, attributes_hash unless name =~ /^(.+?)?([\.#].*)$/
-
-      return $1 || "div", Buffer.merge_attrs(
-        Precompiler.parse_class_and_id($2), attributes_hash)
-    end
-
     # Runs a block of code with the given buffer as the currently active buffer.
     #
     # @param buffer [Haml::Buffer] The Haml buffer to use temporarily

data/vendor/plugins/haml/lib/haml/helpers/action_view_mods.rb

@@ -85,9 +85,7 @@ module ActionView
       module CaptureHelper
         def capture_with_haml(*args, &block)
           if Haml::Helpers.block_is_haml?(block)
-            str = capture_haml(*args, &block)
-            return ActionView::NonConcattingString.new(str) if defined?(ActionView::NonConcattingString)
-            return str
+            capture_haml(*args, &block)
           else
             capture_without_haml(*args, &block)
           end
@@ -107,9 +105,9 @@ module ActionView
           return content_tag_without_haml(name, *args) {preserve(&block)}
         end
 
-        content = content_tag_without_haml(name, *args, &block)
-        content = Haml::Helpers.preserve(content) if preserve && content
-        content
+        returning content_tag_without_haml(name, *args, &block) do |content|
+          return Haml::Helpers.preserve(content) if preserve && content
+        end
       end
 
       alias_method :content_tag_without_haml, :content_tag
@@ -140,8 +138,7 @@ module ActionView
       module FormTagHelper
         def form_tag_with_haml(url_for_options = {}, options = {}, *parameters_for_url, &proc)
           if is_haml?
-            wrap_block = block_given? && block_is_haml?(proc)
-            if wrap_block
+            if block_given?
               oldproc = proc
               proc = haml_bind_proc do |*args|
                 concat "\n"
@@ -149,7 +146,7 @@ module ActionView
               end
             end
             res = form_tag_without_haml(url_for_options, options, *parameters_for_url, &proc) + "\n"
-            res << "\n" if wrap_block
+            res << "\n" if block_given?
             res
           else
             form_tag_without_haml(url_for_options, options, *parameters_for_url, &proc)
@@ -161,40 +158,22 @@ module ActionView
 
       module FormHelper
         def form_for_with_haml(object_name, *args, &proc)
-          wrap_block = block_given? && is_haml? && block_is_haml?(proc)
-          if wrap_block
+          if block_given? && is_haml?
             oldproc = proc
             proc = proc {|*args| with_tabs(1) {oldproc.call(*args)}}
           end
           res = form_for_without_haml(object_name, *args, &proc)
-          res << "\n" if wrap_block
+          res << "\n" if block_given? && is_haml?
           res
         end
         alias_method :form_for_without_haml, :form_for
         alias_method :form_for, :form_for_with_haml
       end
-
-      module CacheHelper
-        # This is a workaround for a Rails 3 bug
-        # that's present at least through beta 3.
-        # Their fragment_for assumes that the block
-        # will return its contents as a string,
-        # which is not always the case.
-        # Luckily, it only makes this assumption if caching is disabled,
-        # so we only override that case.
-        def fragment_for_with_haml(*args, &block)
-          return fragment_for_without_haml(*args, &block) if controller.perform_caching
-          capture(&block)
-        end
-        alias_method :fragment_for_without_haml, :fragment_for
-        alias_method :fragment_for, :fragment_for_with_haml
-      end
     else
       module FormTagHelper
         def form_tag_with_haml(url_for_options = {}, options = {}, *parameters_for_url, &proc)
           if is_haml?
-            wrap_block = block_given? && block_is_haml?(proc)
-            if wrap_block
+            if block_given?
               oldproc = proc
               proc = haml_bind_proc do |*args|
                 concat "\n"
@@ -206,10 +185,7 @@ module ActionView
               concat haml_indent
             end
             res = form_tag_without_haml(url_for_options, options, *parameters_for_url, &proc) + "\n"
-            if block_given?
-              concat "\n"
-              return Haml::Helpers::ErrorReturn.new("form_tag")
-            end
+            concat "\n" if block_given?
             res
           else
             form_tag_without_haml(url_for_options, options, *parameters_for_url, &proc)
@@ -221,8 +197,7 @@ module ActionView
 
       module FormHelper
         def form_for_with_haml(object_name, *args, &proc)
-          wrap_block = block_given? && is_haml? && block_is_haml?(proc)
-          if wrap_block
+          if block_given? && is_haml?
             oldproc = proc
             proc = haml_bind_proc do |*args|
               tab_up
@@ -233,8 +208,7 @@ module ActionView
             concat haml_indent
           end
           form_for_without_haml(object_name, *args, &proc)
-          concat "\n" if wrap_block
-          Haml::Helpers::ErrorReturn.new("form_for") if is_haml?
+          concat "\n" if block_given? && is_haml?
         end
         alias_method :form_for_without_haml, :form_for
         alias_method :form_for, :form_for_with_haml

data/vendor/plugins/haml/lib/haml/helpers/xss_mods.rb

@@ -92,13 +92,6 @@ module Haml
         html_escape(text)
       end
     end
-
-    class ErrorReturn
-      # Any attempt to treat ErrorReturn as a string should cause it to blow up.
-      alias_method :html_safe, :to_s
-      alias_method :html_safe?, :to_s
-      alias_method :html_safe!, :to_s
-    end
   end
 end
 
@@ -119,9 +112,7 @@ module ActionView
 
     module FormTagHelper
       def form_tag_with_haml_xss(*args, &block)
-        res = form_tag_without_haml_xss(*args, &block)
-        res = Haml::Util.html_safe(res) unless block_given?
-        res
+        Haml::Util.html_safe(form_tag_without_haml_xss(*args, &block))
       end
       alias_method :form_tag_without_haml_xss, :form_tag
       alias_method :form_tag, :form_tag_with_haml_xss
@@ -129,9 +120,7 @@ module ActionView
 
     module FormHelper
       def form_for_with_haml_xss(*args, &block)
-        res = form_for_without_haml_xss(*args, &block)
-        return Haml::Util.html_safe(res) if res.is_a?(String)
-        return res
+        Haml::Util.html_safe(form_for_without_haml_xss(*args, &block))
       end
       alias_method :form_for_without_haml_xss, :form_for
       alias_method :form_for, :form_for_with_haml_xss

data/vendor/plugins/haml/lib/haml/html.rb

@@ -9,75 +9,37 @@ module Haml
     # A module containing utility methods that every Hpricot node
     # should have.
     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)
+        parse_text(self.to_s, 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.gsub!('#{', '\#{') #'
+        if text.empty?
+          String.new
+        else
+          lines = text.split("\n")
 
-        text.split("\n").map do |line|
-          line.strip!
-          "#{tabulate(tabs)}#{'\\' if Haml::Engine::SPECIAL_CHARACTERS.include?(line[0])}#{line}\n"
-        end.join
+          lines.map do |line|
+            line.strip!
+            "#{tabulate(tabs)}#{'\\' if Haml::Engine::SPECIAL_CHARACTERS.include?(line[0])}#{line}\n"
+          end.join
+        end
       end
     end
   end
@@ -100,29 +62,9 @@ end
 
 require 'hpricot'
 
-# @private
-HAML_TAGS = %w[haml:block haml:loud haml:silent]
-
-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
-
-HAML_TAGS.each do |t|
-  Hpricot::ElementContent[t] = {}
-  Hpricot::ElementContent.keys.each do |key|
-    Hpricot::ElementContent[t][key.hash] = true
-  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:
   #
@@ -130,7 +72,7 @@ module Haml
   #       #=> "%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
+    # @option options :rhtml [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
@@ -144,11 +86,9 @@ module Haml
           template = template.read
         end
 
-        template = Haml::Util.check_encoding(template) {|msg, line| raise Haml::Error.new(msg, line)}
-
-        if @options[:erb]
-          require 'haml/html/erb'
-          template = ERB.compile(template)
+        if @options[:rhtml]
+          match_to_html(template, /<%=(.*?)-?%>/m, 'loud')
+          match_to_html(template, /<%-?(.*?)-?%>/m,  'silent')
         end
 
         method = @options[:xhtml] ? Hpricot.method(:XML) : method(:Hpricot)
@@ -163,6 +103,7 @@ module Haml
     end
     alias_method :to_haml, :render
 
+    # @private
     TEXT_REGEXP = /^(\s*).*$/
 
     # @see Hpricot
@@ -188,9 +129,7 @@ module Haml
     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}"
+        "#{tabulate(tabs)}:cdata\n#{parse_text(self.content, tabs + 1)}"
       end
     end
 
@@ -201,7 +140,9 @@ module 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
+        if attrs == nil
+          raise Exception.new("Invalid doctype")
+        end
 
         type, version, strictness = attrs.map { |a| a.downcase }
         if type == "html"
@@ -229,17 +170,7 @@ module Haml
     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
+        "#{tabulate(tabs)}/\n#{parse_text(self.content, tabs + 1)}"
       end
     end
 
@@ -248,117 +179,32 @@ module Haml
     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
+        output = "#{tabulate(tabs)}"
+        if options[:rhtml] && name[0...5] == 'haml:'
+          return output + send("haml_tag_#{name[5..-1]}", CGI.unescapeHTML(self.inner_text))
         end
 
-        output << "%#{name}" unless name == 'div' &&
-          (static_id?(options) ||
-           static_classname?(options) &&
-           attr_hash['class'].split(' ').any?(&method(:haml_css_attr?)))
+        output += "%#{name}" unless name == 'div' &&
+          (static_id?(options) || static_classname?(options))
 
         if attr_hash
           if static_id?(options)
-            output << "##{attr_hash['id']}"
+            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
+            attr_hash['class'].split(' ').each { |c| output += ".#{c}" }
             remove_attribute('class')
-            set_attribute('class', leftover.join(' ')) unless leftover.empty?
           end
-          output << haml_attributes(options) if attr_hash.length > 0
+          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
+        (self.children || []).inject(output + "\n") do |output, child|
+          output + child.to_haml(tabs + 1, options)
         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
@@ -375,53 +221,47 @@ module Haml
         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
+      def haml_tag_loud(text)
+        "= #{text.gsub(/\n\s*/, ' ').strip}\n"
+      end
 
-        "#{tabulate(tabs)}:#{filter}\n#{content}"
+      def haml_tag_silent(text)
+        text.split("\n").map { |line| "- #{line.strip}\n" }.join
       end
 
       def static_attribute?(name, options)
-        attr_hash[name] && !dynamic_attribute?(name, options)
+        attr_hash[name] and !dynamic_attribute?(name, options)
       end
       
       def dynamic_attribute?(name, options)
-        options[:erb] and dynamic_attributes.key?(name)
+        options[:rhtml] and dynamic_attributes.key?(name)
       end
       
       def static_id?(options)
-        static_attribute?('id', options) && haml_css_attr?(attr_hash['id'])
+        static_attribute?('id', options)
       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|
+        attrs = attr_hash.map do |name, value|
           value = dynamic_attribute?(name, options) ? dynamic_attributes[name] : value.inspect
           name = name.index(/\W/) ? name.inspect : ":#{name}"
           "#{name} => #{value}"
         end
-        "{#{attrs.join(', ')}}"
+        "{ #{attrs.join(', ')} }"
+      end
+    end
+
+    private
+
+    def match_to_html(string, regex, tag)
+      string.gsub!(regex) do
+        "<haml:#{tag}>#{CGI.escapeHTML($1)}</haml:#{tag}>"
       end
     end
   end