haml 1.8.0 → 2.0.3

data/lib/haml/helpers.rb

@@ -34,25 +34,44 @@ module Haml
     #     include Haml::Helpers
     #   end
     #   context.init_haml_helpers
-    #   context.open :p, "Stuff"
-    # 
+    #   context.haml_tag :p, "Stuff"
+    #
     def init_haml_helpers
-      @haml_is_haml = true
-      @haml_stack = [Haml::Buffer.new]
+      @haml_buffer = Haml::Buffer.new(@haml_buffer, Haml::Engine.new('').send(:options_for_buffer))
       nil
     end
 
     # call-seq:
-    #   find_and_preserve(input)
+    #   non_haml { ... }
+    #
+    # Runs a block of code in a non-Haml context
+    # (i.e. #is_haml? will return false).
+    #
+    # This is mainly useful for rendering sub-templates such as partials in a non-Haml language,
+    # particularly where helpers may behave differently when run from Haml.
+    #
+    # Note that this is automatically applied to Rails partials.
+    def non_haml
+      was_active = @haml_buffer.active?
+      @haml_buffer.active = false
+      res = yield
+      @haml_buffer.active = was_active
+      res
+    end
+
+    # call-seq:
+    #   find_and_preserve(input, tags = haml_buffer.options[:preserve])
     #   find_and_preserve {...}
-    #   
-    # Isolates the whitespace-sensitive tags in the string and uses preserve
-    # to convert any endlines inside them into HTML entities for endlines.
-    def find_and_preserve(input = '', &block)
+    #
+    # Uses preserve to convert any newlines inside whitespace-sensitive tags
+    # into the HTML entities for endlines.
+    # @tags@ is an array of tags to preserve.
+    # It defaults to the value of the <tt>:preserve</tt> option.
+    def find_and_preserve(input = '', tags = haml_buffer.options[:preserve], &block)
       return find_and_preserve(capture_haml(&block)) if block
 
       input = input.to_s
-      input.gsub(/<(textarea|code|pre)([^>]*)>(.*?)(<\/\1>)/im) do
+      input.gsub(/<(#{tags.map(&Regexp.method(:escape)).join('|')})([^>]*)>(.*?)(<\/\1>)/im) do
         "<#{$1}#{$2}>#{preserve($3)}</#{$1}>"
       end
     end
@@ -67,7 +86,7 @@ module Haml
     def preserve(input = '', &block)
       return preserve(capture_haml(&block)) if block
 
-      input.gsub(/\n/, '&#x000A;').gsub(/\r/, '')
+      input.chomp("\n").gsub(/\n/, '&#x000A;').gsub(/\r/, '')
     end
 
     alias_method :flatten, :preserve
@@ -107,14 +126,14 @@ module Haml
     def list_of(array, &block) # :yields: item
       to_return = array.collect do |i|
         result = capture_haml(i, &block)
-        
+
         if result.count("\n") > 1
           result.gsub!("\n", "\n  ")
           result = "\n  #{result.strip}\n"
         else
           result.strip!
         end
-        
+
         "<li>#{result}</li>"
       end
       to_return.join("\n")
@@ -153,17 +172,17 @@ module Haml
     #   <strong>baz</strong>
     #
     def tab_up(i = 1)
-      buffer.tabulation += i
+      haml_buffer.tabulation += i
     end
 
-    # Increments the number of tabs the buffer automatically adds
+    # Decrements the number of tabs the buffer automatically adds
     # to the lines of the template.
     #
-    # See tab_up.
+    # See also tab_up.
     def tab_down(i = 1)
-      buffer.tabulation -= i
+      haml_buffer.tabulation -= i
     end
-    
+
     # Surrounds the given block of Haml code with the given characters,
     # with no whitespace in between.
     # For example:
@@ -187,10 +206,10 @@ module Haml
     def surround(front, back = nil, &block)
       back ||= front
       output = capture_haml(&block)
-      
+
       "#{front}#{output.chomp}#{back}\n"
     end
-    
+
     # Prepends the given character to the beginning of the Haml block,
     # with no whitespace between.
     # For example:
@@ -205,7 +224,7 @@ module Haml
     def precede(char, &block)
       "#{char}#{capture_haml(&block).chomp}\n"
     end
-    
+
     # Appends the given character to the end of the Haml block,
     # with no whitespace between.
     # For example:
@@ -222,7 +241,7 @@ module Haml
     def succeed(char, &block)
       "#{capture_haml(&block).chomp}#{char}\n"
     end
-    
+
     # Captures the result of the given block of Haml code,
     # gets rid of the excess indentation,
     # and returns it as a string.
@@ -235,35 +254,40 @@ module Haml
     # the local variable <tt>foo</tt> would be assigned to "<p>13</p>\n".
     #
     def capture_haml(*args, &block)
-      capture_haml_with_buffer(buffer.buffer, *args, &block)
+      capture_haml_with_buffer(haml_buffer.buffer, *args, &block)
     end
 
     # Outputs text directly to the Haml buffer, with the proper tabulation
     def puts(text = "")
-      buffer.buffer << ('  ' * buffer.tabulation) << text.to_s << "\n"
+      haml_buffer.buffer << ('  ' * haml_buffer.tabulation) << text.to_s << "\n"
       nil
     end
 
     #
     # call-seq:
-    #   open(name, attributes = {}) {...}
-    #   open(name, text, attributes = {}) {...}
+    #   haml_tag(name, *flags, attributes = {}) {...}
+    #   haml_tag(name, text, *flags, attributes = {}) {...}
     #
     # Creates an HTML tag with the given name and optionally text and attributes.
     # Can take a block that will be executed
     # between when the opening and closing tags are output.
     # If the block is a Haml block or outputs text using puts,
     # the text will be properly indented.
-    # 
+    #
+    # <tt>flags</tt> is a list of symbol flags
+    # like those that can be put at the end of a Haml tag
+    # (<tt>:/</tt>, <tt>:<</tt>, and <tt>:></tt>).
+    # Currently, only <tt>:/</tt> and <tt>:<</tt> are supported.
+    #
     # For example,
     #
-    #   open :table do
-    #     open :tr do
-    #       open :td, {:class => 'cell'} do
-    #         open :strong, "strong!"
+    #   haml_tag :table do
+    #     haml_tag :tr do
+    #       haml_tag :td, {:class => 'cell'} do
+    #         haml_tag :strong, "strong!"
     #         puts "data"
     #       end
-    #       open :td do
+    #       haml_tag :td do
     #         puts "more_data"
     #       end
     #     end
@@ -285,87 +309,124 @@ module Haml
     #     </tr>
     #   </table>
     #
-    def open(name, attributes = {}, alt_atts = {}, &block)
-      text = nil
-      if attributes.is_a? String
-        text = attributes
-        attributes = alt_atts
-      end
+    def haml_tag(name, *rest, &block)
+      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
+      attributes = Haml::Precompiler.build_attributes(haml_buffer.html?,
+                                                      haml_buffer.options[:attr_wrapper],
+                                                      rest.shift || {})
 
-      if text.nil? && block.nil?
-        puts "<#{name}#{Haml::Precompiler.build_attributes(buffer.options[:attr_wrapper], attributes)} />"
+      if text.nil? && block.nil? && (haml_buffer.options[:autoclose].include?(name) || flags.include?(:/))
+        puts "<#{name}#{attributes} />"
         return nil
       end
 
-      puts "<#{name}#{Haml::Precompiler.build_attributes(buffer.options[:attr_wrapper], attributes)}>"
-      unless text && text.empty?
-        tab_up
-        # Print out either the text (using push_text) or call the block and add an endline
-        if text
-          puts(text)
-        elsif block
-          block.call
-        end
-        tab_down
+      if flags.include?(:/)
+        raise Error.new("Self-closing tags can't have content.") if text
+        raise Error.new("Illegal nesting: nesting within a self-closing tag is illegal.") if block
+      end
+
+      tag = "<#{name}#{attributes}>"
+      if block.nil?
+        tag << text.to_s << "</#{name}>"
+        puts tag
+        return
       end
+
+      if text
+        raise Error.new("Illegal nesting: content can't be both given to haml_tag :#{name} and nested within it.")
+      end
+
+      if flags.include?(:<)
+        tag << capture_haml(&block).strip << "</#{name}>"
+        puts tag
+        return
+      end
+
+      puts tag
+      tab_up
+      block.call
+      tab_down
       puts "</#{name}>"
       nil
     end
-    
+
+    # Characters that need to be escaped to HTML entities from user input
+    HTML_ESCAPE = { '&'=>'&amp;', '<'=>'&lt;', '>'=>'&gt;', '"'=>'&quot;', "'"=>'&#039;', }
+
+    # Returns a copy of <tt>text</tt> with ampersands, angle brackets and quotes
+    # escaped into HTML entities.
+    def html_escape(text)
+      text.to_s.gsub(/[\"><&]/) { |s| HTML_ESCAPE[s] }
+    end
+
+    # Escapes HTML entities in <tt>text</tt>, but without escaping an ampersand
+    # that is already part of an escaped entity.
+    def escape_once(text)
+      text.to_s.gsub(/[\"><]|&(?!([a-zA-Z]+|(#\d+));)/) { |s| HTML_ESCAPE[s] }
+    end
+
+    # Returns whether or not the current template is a Haml template.
+    #
+    # This function, unlike other Haml::Helpers functions,
+    # also works in other ActionView templates,
+    # where it will always return false.
+    def is_haml?
+      !@haml_buffer.nil? && @haml_buffer.active?
+    end
+
     private
 
     # Gets a reference to the current Haml::Buffer object.
-    def buffer
-      @haml_stack[-1]
+    def haml_buffer
+      @haml_buffer
     end
-    
+
     # Gives a proc the same local "_hamlout" and "_erbout" variables
     # that the current template has.
-    def bind_proc(&proc)
-      _hamlout = buffer
+    def haml_bind_proc(&proc)
+      _hamlout = haml_buffer
       _erbout = _hamlout.buffer
       proc { |*args| proc.call(*args) }
     end
-    
+
     # Performs the function of capture_haml, assuming <tt>local_buffer</tt>
     # is where the output of block goes.
     def capture_haml_with_buffer(local_buffer, *args, &block)
       position = local_buffer.length
-      
-      block.call *args
-      
+
+      block.call(*args)
+
       captured = local_buffer.slice!(position..-1)
-      
+
       min_tabs = nil
       captured.each do |line|
         tabs = line.index(/[^ ]/)
         min_tabs ||= tabs
         min_tabs = min_tabs > tabs ? tabs : min_tabs
       end
-      
+
       result = captured.map do |line|
         line[min_tabs..-1]
       end
       result.to_s
     end
 
-    # Returns whether or not the current template is a Haml template.
-    # 
-    # This function, unlike other Haml::Helpers functions,
-    # also works in other ActionView templates,
-    # where it will always return false.
-    def is_haml?
-      @haml_is_haml
-    end
-
     include ActionViewExtensions if self.const_defined? "ActionViewExtensions"
   end
 end
 
-module ActionView
-  class Base # :nodoc:
-    def is_haml?
-      false
-    end
+class Object
+  # Haml overrides various ActionView helpers,
+  # which call an #is_haml? method
+  # to determine whether or not the current context object
+  # is a proper Haml context.
+  # Because ActionView helpers may be included in non-ActionView::Base classes,
+  # it's a good idea to define is_haml? for all objects.
+  def is_haml?
+    false
   end
 end
+

data/lib/haml/html.rb

@@ -29,7 +29,7 @@ module Haml
         end
 
         method = @@options[:xhtml] ? Hpricot.method(:XML) : method(:Hpricot)
-        @template = method.call(template)
+        @template = method.call(template.gsub('&', '&'))
       end
     end
 
@@ -59,7 +59,7 @@ module Haml
           String.new
         else
           lines = text.split("\n")
-          
+
           lines.map do |line|
             line.strip!
             "#{tabulate(tabs)}#{'\\' if Haml::Engine::SPECIAL_CHARACTERS.include?(line[0])}#{line}\n"
@@ -73,7 +73,7 @@ module Haml
     def self.options
       @@options
     end
-    
+
     TEXT_REGEXP = /^(\s*).*$/
 
     class ::Hpricot::Doc
@@ -129,14 +129,14 @@ module Haml
 
     class ::Hpricot::Elem
       def to_haml(tabs = 0)
-        output = "#{tabulate(tabs)}"        
+        output = "#{tabulate(tabs)}"
         if HTML.options[:rhtml] && name[0...5] == 'haml:'
           return output + HTML.send("haml_tag_#{name[5..-1]}",
                                     CGI.unescapeHTML(self.innerHTML))
         end
 
         output += "%#{name}" unless name == 'div' && (attributes.include?('id') || attributes.include?('class'))
-        
+
         if attributes
           output += "##{attributes['id']}" if attributes['id']
           attributes['class'].split(' ').each { |c| output += ".#{c}" } if attributes['class']
@@ -144,10 +144,10 @@ module Haml
           remove_attribute('class')
           output += haml_attributes if attributes.length > 0
         end
-        
+
         output += "/" if children.length == 0
         output += "\n"
-        
+
         self.children.each do |child|
           output += child.to_haml(tabs + 1)
         end
@@ -169,7 +169,7 @@ module Haml
     end
 
     def self.haml_tag_loud(text)
-      "= #{text.gsub(/\n\s*/, '; ').strip}\n"
+      "= #{text.gsub(/\n\s*/, ' ').strip}\n"
     end
 
     def self.haml_tag_silent(text)