haml 2.2.24 → 3.0.0.beta.1

data/lib/haml/filters.rb

@@ -100,11 +100,7 @@ module Haml
           if contains_interpolation?(text)
             return if options[:suppress_eval]
 
-            text = unescape_interpolation(text).gsub(/(\\+)n/) do |s|
-              escapes = $1.size
-              next s if escapes % 2 == 0
-              ("\\" * (escapes - 1)) + "\n"
-            end
+            text = unescape_interpolation(text).gsub("\\n", "\n")
             newline if text.gsub!(/\n"\Z/, "\\n\"")
             push_script <<RUBY.strip, :escape_html => false
 find_and_preserve(#{filter.inspect}.render_with_options(#{text}, _hamlout.options))
@@ -210,6 +206,23 @@ 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
@@ -281,7 +294,7 @@ END
       end
     end
 
-    # Parses the filtered text with ERB, like an RHTML template.
+    # Parses the filtered text with ERB.
     # 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
@@ -308,8 +321,6 @@ END
         ::RedCloth.new(text).to_html(:textile)
       end
     end
-    # An alias for the Textile filter,
-    # since the only available Textile parser is RedCloth.
     RedCloth = Textile
     Filters.defined['redcloth'] = RedCloth
 

data/lib/haml/helpers.rb

@@ -1,3 +1,8 @@
+if defined?(ActionView)
+  require 'haml/helpers/action_view_mods'
+  require 'haml/helpers/action_view_extensions'
+end
+
 module Haml
   # This module contains various helpful methods to make it easier to do various tasks.
   # {Haml::Helpers} is automatically included in the context
@@ -47,7 +52,8 @@ MESSAGE
 
     self.extend self
 
-    @@action_view_defined = false
+    @@action_view_defined = defined?(ActionView)
+    @@force_no_action_view = false
 
     # @return [Boolean] Whether or not ActionView is loaded
     def self.action_view?
@@ -359,22 +365,16 @@ 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 = "")
-      haml_buffer.buffer << haml_indent << text.to_s << "\n"
+      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
       ErrorReturn.new("haml_concat")
     end
 
@@ -388,6 +388,11 @@ END
     # 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 `:>`).
@@ -402,7 +407,7 @@ END
     #
     #     haml_tag :table do
     #       haml_tag :tr do
-    #         haml_tag :td, {:class => 'cell'} do
+    #         haml_tag 'td.cell' do
     #           haml_tag :strong, "strong!"
     #           haml_concat "data"
     #         end
@@ -438,13 +443,14 @@ END
     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
+      name, attrs = merge_name_and_attributes(name.to_s, rest.shift || {})
+
       attributes = Haml::Precompiler.build_attributes(haml_buffer.html?,
                                                       haml_buffer.options[:attr_wrapper],
-                                                      rest.shift || {})
+                                                      attrs)
 
       if text.nil? && block.nil? && (haml_buffer.options[:autoclose].include?(name) || flags.include?(:/))
         haml_concat "<#{name}#{attributes} />"
@@ -458,8 +464,17 @@ END
 
       tag = "<#{name}#{attributes}>"
       if block.nil?
-        tag << text.to_s << "</#{name}>"
-        haml_concat tag
+        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
         return ret
       end
 
@@ -496,7 +511,7 @@ END
     # @param text [String] The string to sanitize
     # @return [String] The sanitized string
     def html_escape(text)
-      Haml::Util.silence_warnings {text.to_s.gsub(/[\"><&]/n) {|s| HTML_ESCAPE[s]}}
+      text.to_s.gsub(/[\"><&]/n) {|s| HTML_ESCAPE[s]}
     end
 
     # Escapes HTML entities in `text`, but without escaping an ampersand
@@ -534,6 +549,17 @@ END
 
     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),
+        Haml::Util.map_keys(attributes_hash) {|key| key.to_s})
+    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
@@ -566,10 +592,11 @@ END
       _erbout = _hamlout.buffer
       proc { |*args| proc.call(*args) }
     end
+
+    include ActionViewExtensions if self.const_defined? "ActionViewExtensions"
   end
 end
 
-# @private
 class Object
   # Haml overrides various `ActionView` helpers,
   # which call an \{#is\_haml?} method

data/lib/haml/helpers/action_view_extensions.rb

@@ -1,7 +1,7 @@
+require 'haml/helpers/action_view_mods'
+
 module Haml
   module Helpers
-    @@action_view_defined = true
-
     # This module contains various useful helper methods
     # that either tie into ActionView or the rest of the ActionPack stack,
     # or are only useful in that context.
@@ -51,7 +51,5 @@ module Haml
         @_haml_concat_raw = old
       end
     end
-
-    include ActionViewExtensions
   end
 end

data/lib/haml/helpers/action_view_mods.rb

@@ -125,12 +125,9 @@ module ActionView
         @template_object.send :is_haml?
       end
 
-      def content_tag(*args)
-        html_tag = content_tag_with_haml(*args)
-        return html_tag unless respond_to?(:error_wrapping)
-        return error_wrapping(html_tag) if method(:error_wrapping).arity == 1
-        return html_tag unless object.respond_to?(:errors) && object.errors.respond_to?(:on)
-        return error_wrapping(html_tag, object.errors.on(@method_name))
+      unless defined?(ActionView::Helpers) && defined?(ActionView::Helpers::ActiveRecordInstanceTag)
+        alias_method :content_tag_without_haml, :content_tag
+        alias_method :content_tag, :content_tag_with_haml
       end
     end
 
@@ -160,7 +157,9 @@ module ActionView
         def form_for_with_haml(object_name, *args, &proc)
           if block_given? && is_haml?
             oldproc = proc
-            proc = proc {|*args| with_tabs(1) {oldproc.call(*args)}}
+            proc = haml_bind_proc do |*args|
+              with_tabs(1) {oldproc.call(*args)}
+            end
           end
           res = form_for_without_haml(object_name, *args, &proc)
           res << "\n" if block_given? && is_haml?
@@ -185,7 +184,10 @@ module ActionView
               concat haml_indent
             end
             res = form_tag_without_haml(url_for_options, options, *parameters_for_url, &proc) + "\n"
-            concat "\n" if block_given?
+            if block_given?
+              concat "\n"
+              return Haml::Helpers::ErrorReturn.new("form_tag")
+            end
             res
           else
             form_tag_without_haml(url_for_options, options, *parameters_for_url, &proc)
@@ -209,6 +211,7 @@ module ActionView
           end
           form_for_without_haml(object_name, *args, &proc)
           concat "\n" if block_given? && is_haml?
+          Haml::Helpers::ErrorReturn.new("form_for") if is_haml?
         end
         alias_method :form_for_without_haml, :form_for
         alias_method :form_for, :form_for_with_haml

data/lib/haml/helpers/xss_mods.rb

@@ -92,6 +92,13 @@ 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
 
@@ -112,7 +119,9 @@ module ActionView
 
     module FormTagHelper
       def form_tag_with_haml_xss(*args, &block)
-        Haml::Util.html_safe(form_tag_without_haml_xss(*args, &block))
+        res = form_tag_without_haml_xss(*args, &block)
+        res = Haml::Util.html_safe(res) unless block_given?
+        res
       end
       alias_method :form_tag_without_haml_xss, :form_tag
       alias_method :form_tag, :form_tag_with_haml_xss
@@ -120,7 +129,9 @@ module ActionView
 
     module FormHelper
       def form_for_with_haml_xss(*args, &block)
-        Haml::Util.html_safe(form_for_without_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
       end
       alias_method :form_for_without_haml_xss, :form_for
       alias_method :form_for, :form_for_with_haml_xss

data/lib/haml/html.rb

@@ -9,37 +9,75 @@ 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)
-        parse_text(self.to_s, tabs)
+        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!
-        text.gsub!('#{', '\#{') #'
-        if text.empty?
-          String.new
-        else
-          lines = text.split("\n")
+        return "" if text.empty?
 
-          lines.map do |line|
-            line.strip!
-            "#{tabulate(tabs)}#{'\\' if Haml::Engine::SPECIAL_CHARACTERS.include?(line[0])}#{line}\n"
-          end.join
-        end
+        text.split("\n").map do |line|
+          line.strip!
+          "#{tabulate(tabs)}#{'\\' if Haml::Engine::SPECIAL_CHARACTERS.include?(line[0])}#{line}\n"
+        end.join
       end
     end
   end
@@ -65,6 +103,9 @@ require 'hpricot'
 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:
   #
@@ -72,7 +113,7 @@ module Haml
   #       #=> "%a{:href => 'http://google.com'} Blat"
   class HTML
     # @param template [String, Hpricot::Node] The HTML template to convert
-    # @option options :rhtml [Boolean] (false) Whether or not to parse
+    # @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
@@ -86,9 +127,11 @@ module Haml
           template = template.read
         end
 
-        if @options[:rhtml]
-          match_to_html(template, /<%=(.*?)-?%>/m, 'loud')
-          match_to_html(template, /<%-?(.*?)-?%>/m,  'silent')
+        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)
         end
 
         method = @options[:xhtml] ? Hpricot.method(:XML) : method(:Hpricot)
@@ -129,7 +172,9 @@ module Haml
     class ::Hpricot::CData
       # @see Haml::HTML::Node#to_haml
       def to_haml(tabs, options)
-        "#{tabulate(tabs)}:cdata\n#{parse_text(self.content, tabs + 1)}"
+        content = parse_text_with_interpolation(
+          erb_to_interpolation(self.content, options), tabs + 1)
+        "#{tabulate(tabs)}:cdata\n#{content}"
       end
     end
 
@@ -140,9 +185,7 @@ module Haml
       def to_haml(tabs, options)
         attrs = public_id.nil? ? ["", "", ""] :
           public_id.scan(/DTD\s+([^\s]+)\s*([^\s]*)\s*([^\s]*)\s*\/\//)[0]
-        if attrs == nil
-          raise Exception.new("Invalid doctype")
-        end
+        raise Haml::SyntaxError.new("Invalid doctype") if attrs == nil
 
         type, version, strictness = attrs.map { |a| a.downcase }
         if type == "html"
@@ -170,7 +213,17 @@ module Haml
     class ::Hpricot::Comment
       # @see Haml::HTML::Node#to_haml
       def to_haml(tabs, options)
-        "#{tabulate(tabs)}/\n#{parse_text(self.content, tabs + 1)}"
+        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}"
+        end
       end
     end
 
@@ -179,32 +232,104 @@ module Haml
     class ::Hpricot::Elem
       # @see Haml::HTML::Node#to_haml
       def to_haml(tabs, options)
-        output = "#{tabulate(tabs)}"
-        if options[:rhtml] && name[0...5] == 'haml:'
-          return output + send("haml_tag_#{name[5..-1]}", CGI.unescapeHTML(self.inner_text))
+        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 += "%#{name}" unless name == 'div' &&
-          (static_id?(options) || static_classname?(options))
+        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
+
+        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']}"
+            output << "##{attr_hash['id']}"
             remove_attribute('id')
           end
           if static_classname?(options)
-            attr_hash['class'].split(' ').each { |c| output += ".#{c}" }
+            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
+          output << haml_attributes(options) if attr_hash.length > 0
         end
 
-        (self.children || []).inject(output + "\n") do |output, child|
-          output + child.to_haml(tabs + 1, options)
+        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
@@ -221,47 +346,53 @@ module Haml
         end
       end
 
-      def haml_tag_loud(text)
-        "= #{text.gsub(/\n\s*/, ' ').strip}\n"
-      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_silent(text)
-        text.split("\n").map { |line| "- #{line.strip}\n" }.join
+        "#{tabulate(tabs)}:#{filter}\n#{content}"
       end
 
       def static_attribute?(name, options)
-        attr_hash[name] and !dynamic_attribute?(name, options)
+        attr_hash[name] && !dynamic_attribute?(name, options)
       end
       
       def dynamic_attribute?(name, options)
-        options[:rhtml] and dynamic_attributes.key?(name)
+        options[:erb] and dynamic_attributes.key?(name)
       end
       
       def static_id?(options)
-        static_attribute?('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.map do |name, value|
+        attrs = attr_hash.sort.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(', ')} }"
-      end
-    end
-
-    private
-
-    def match_to_html(string, regex, tag)
-      string.gsub!(regex) do
-        "<haml:#{tag}>#{CGI.escapeHTML($1)}</haml:#{tag}>"
+        "{#{attrs.join(', ')}}"
       end
     end
   end