haml 1.0.5 → 1.5.0

data/lib/haml/buffer.rb

@@ -52,7 +52,7 @@ module Haml
     # instance_eval.
     def push_script(result, tabulation, flattened)
       if flattened
-        result = find_and_flatten(result)
+        result = Haml::Helpers.find_and_preserve(result)
       end
       unless result.nil?
         result = result.to_s
@@ -71,8 +71,8 @@ module Haml
     # 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!(parse_object_ref(obj_ref, attributes[:id], attributes[:class])) if obj_ref
       attributes.merge!(attributes_hash) if attributes_hash
 
       @one_liner_pending = false
@@ -157,20 +157,30 @@ module Haml
 
     # 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)
+    def parse_object_ref(ref, old_id, old_class)
       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}
+      id = "#{class_name}_#{ref.id}"
+
+      if old_class
+        class_name += " #{old_class}"
+      end
+
+      if old_id
+        id = "#{old_id}_#{id}"
+      end
+
+      {:id => 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
+        v = v.to_s
+        unless v.nil? || v.empty?
           attr_wrapper = @options[:attr_wrapper]
           if v.include? attr_wrapper
             if v.include? @other_quote_char
@@ -190,35 +200,28 @@ module Haml
     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)
+unless String.methods.include? 'old_comp'
+  class String # :nodoc
+    alias_method :old_comp, :<=>
+    
+    def <=>(other)
+      if other.is_a? NilClass
+        -1
+      else
+        old_comp(other)
+      end
     end
   end
-end
-
-class NilClass # :nodoc:
-  include Comparable
-  
-  def <=>(other)
-    other.nil? ? 0 : 1
+    
+  class NilClass # :nodoc:
+    include Comparable
+    
+    def <=>(other)
+      other.nil? ? 0 : 1
+    end
   end
 end
 

data/lib/haml/engine.rb

@@ -1,12 +1,14 @@
-require File.dirname(__FILE__) + '/helpers'
-require File.dirname(__FILE__) + '/buffer'
+require 'haml/helpers'
+require 'haml/buffer'
+require 'haml/filters'
+require 'haml/error'
 
 module Haml
-  # This is the class where all the parsing and processing of the 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:
+  # new instance and calling <tt>to_html</tt> to render the template. For example:
   #
-  #   template = File.load('templates/really_cool_template.haml')
+  #   template = File.read('templates/really_cool_template.haml')
   #   haml_engine = Haml::Engine.new(template)
   #   output = haml_engine.to_html
   #   puts output
@@ -18,34 +20,37 @@ module Haml
     attr :options, true
 
     # Designates an XHTML/XML element.
-    ELEMENT         = '%'[0]
+    ELEMENT         = ?%
 
     # Designates a <tt><div></tt> element with the given class.
-    DIV_CLASS       = '.'[0]
+    DIV_CLASS       = ?.
 
     # Designates a <tt><div></tt> element with the given id.
-    DIV_ID          = '#'[0]
+    DIV_ID          = ?#
 
     # Designates an XHTML/XML comment.
-    COMMENT         = '/'[0]
+    COMMENT         = ?/
 
     # Designates an XHTML doctype.
-    DOCTYPE         = '!'[0]
+    DOCTYPE         = ?!
 
     # Designates script, the result of which is output.
-    SCRIPT          = '='[0]
+    SCRIPT          = ?=
 
     # Designates script, the result of which is flattened and output.
-    FLAT_SCRIPT     = '~'[0]
+    FLAT_SCRIPT     = ?~
 
     # Designates script which is run but not output.
-    SILENT_SCRIPT   = '-'[0]
+    SILENT_SCRIPT   = ?-
 
     # When following SILENT_SCRIPT, designates a comment that is not output.
-    SILENT_COMMENT  = '#'[0]
+    SILENT_COMMENT  = ?#
 
     # Designates a non-parsed line.
-    ESCAPE          = '\\'[0]
+    ESCAPE          = ?\\
+
+    # Designates a block of filtered text.
+    FILTER          = ?:
 
     # Designates a non-parsed line. Not actually a character.
     PLAIN_TEXT      = -1
@@ -61,16 +66,17 @@ module Haml
       SCRIPT,
       FLAT_SCRIPT,
       SILENT_SCRIPT,
-      ESCAPE
+      ESCAPE,
+      FILTER
     ]
 
     # The value of the character that designates that a line is part
     # of a multiline string.
-    MULTILINE_CHAR_VALUE = '|'[0]
+    MULTILINE_CHAR_VALUE = ?|
 
     # Characters that designate that a multiline string may be about
     # to begin.
-    MULTILINE_STARTERS   = SPECIAL_CHARACTERS - ["/"[0]]
+    MULTILINE_STARTERS   = SPECIAL_CHARACTERS - [?/]
 
     # Keywords that appear in the middle of a Ruby block with lowered
     # indentation. If a block has been started using indentation,
@@ -86,39 +92,87 @@ module Haml
     # is a member of this array.
     MID_BLOCK_KEYWORDS   = ['else', 'elsif', 'rescue', 'ensure', 'when']
 
+    # The Regex that matches an HTML comment command.
+    COMMENT_REGEX = /\/(\[[a-zA-Z0-9 \.]*\])?(.*)/
+
+    # The Regex that matches a Doctype command.
+    DOCTYPE_REGEX = /([0-9]\.[0-9])?[\s]*([a-zA-Z]*)/
+
+    # The Regex that matches an HTML tag command.
+    TAG_REGEX = /[%]([-:_a-zA-Z0-9]+)([-_a-zA-Z0-9\.\#]*)(\{.*\})?(\[.*\])?([=\/\~]?)?(.*)?/
+
+    FLAT_WARNING = <<END
+Haml deprecation warning:
+The ~ command is deprecated and will be removed in future Haml versions.
+Use the :preserve filter, the preserve helper, or the find_and_preserve
+helper instead.
+END
+
     # 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.
+    # See README for available options.
     #
     #--
     # When adding options, remember to add information about them
-    # to REFERENCE!
+    # to README!
     #++
     #
     def initialize(template, options = {})
       @options = {
         :suppress_eval => false,
         :attr_wrapper => "'",
-        :locals => {}
-      }.merge options
+        :locals => {},
+        :filters => {
+          'sass' => Sass::Engine,
+          'plain' => Haml::Filters::Plain,
+          'preserve' => Haml::Filters::Preserve
+        }
+      }
+
+      unless @options[:suppress_eval]
+        @options[:filters].merge!({
+          'erb' => ERB,
+          'ruby' => Haml::Filters::Ruby
+        })
+      end
+
+      if !NOT_LOADED.include? 'redcloth'
+        @options[:filters].merge!({
+          'redcloth' => RedCloth,
+          'textile' => Haml::Filters::Textile,
+          'markdown' => Haml::Filters::Markdown
+        })
+      end
+      if !NOT_LOADED.include? 'bluecloth'
+        @options[:filters]['markdown'] = Haml::Filters::Markdown
+      end
+
+      @options.rec_merge! options
+
       @precompiled = @options[:precompiled]
 
       @template = template.strip #String
       @to_close_stack = []
       @output_tabs = 0
       @template_tabs = 0
+      @index = 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)
+      begin
+        # 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)
+      rescue Haml::Error => e
+        e.add_backtrace_entry(@index, @options[:filename])
+        raise e
+      end
     end
 
     # Processes the template and returns the result as a string.
-    def to_html(scope = Object.new, &block)
+    def render(scope = Object.new, &block)
       @scope_object = scope
       @buffer = Haml::Buffer.new(@options)
 
@@ -139,6 +193,8 @@ module Haml
       @buffer.buffer
     end
 
+    alias_method :to_html, :render
+
    private
 
     #Precompile each line
@@ -153,26 +209,38 @@ module Haml
       old_index = nil
       old_spaces = nil
       old_tabs = nil
-      (@template + "\n-#").each_with_index do |line, index|
+      old_uline = nil
+      (@template + "\n-#\n-#").each_with_index do |line, index|
         spaces, tabs = count_soft_tabs(line)
-        line = line.strip
+        uline = line.lstrip[0...-1]
+        line = uline.rstrip
         
         if !line.empty?
           if old_line
             block_opened = tabs > old_tabs && !line.empty?
             
-            suppress_render = handle_multiline(old_tabs, old_line, old_index)
+            suppress_render = handle_multiline(old_tabs, old_line, old_index) unless @flat_spaces != -1
             
             if !suppress_render
               line_empty = old_line.empty?
+
               process_indent(old_tabs, old_line) unless line_empty
               flat = @flat_spaces != -1
 
+
+              if !flat && old_spaces != old_tabs * 2
+                raise SyntaxError.new("Illegal Indentation: Only two space characters are allowed as tabulation.")
+              end
+
               if flat
-                push_flat(old_line, old_spaces)
+                push_flat(old_uline, old_spaces)
               elsif !line_empty
                 process_line(old_line, old_index, block_opened)
               end
+
+              if @flat_spaces == -1 && tabs - old_tabs > 1
+                raise SyntaxError.new("Illegal Indentation: Indenting more than once per line is illegal.")
+              end
             end
           end
           
@@ -180,10 +248,16 @@ module Haml
           old_index = index
           old_spaces = spaces
           old_tabs = tabs
+          old_uline = uline
         elsif @flat_spaces != -1
-          push_flat(old_line, old_spaces)
-          old_line = ''
-          old_spaces = 0
+          process_indent(old_tabs, old_line) unless old_line.empty?
+
+          if @flat_spaces != -1
+            push_flat(old_line, old_spaces)
+            old_line = ''
+            old_uline = ''
+            old_spaces = 0
+          end
         end
       end
 
@@ -207,40 +281,52 @@ module Haml
       end
     end
 
-    # Processes a single line of HAML.
+    # 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)
+      @index = index + 1
+      @block_opened = block_opened
+
       case line[0]
       when DIV_CLASS, DIV_ID
-        render_div(line, index)
+        render_div(line)
       when ELEMENT
-        render_tag(line, index)
+        render_tag(line)
       when COMMENT
         render_comment(line)
       when SCRIPT
-        push_script(line[1..-1], false, block_opened, index)
+        sub_line = line[1..-1]
+        if sub_line[0] == SCRIPT
+          push_script(sub_line[1..-1].strip.dump.gsub('\\#', '#'), false)
+        else
+          push_script(sub_line, false)
+        end
       when FLAT_SCRIPT
-        push_flat_script(line[1..-1], block_opened, index)
+        warn(FLAT_WARNING) unless defined?(Test::Unit)
+        push_flat_script(line[1..-1])
       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_silent(sub_line, true)
+          if @block_opened && !mid_block_keyword?(line)
             push_and_tabulate([:script])
           end
         end
+      when FILTER
+        name = line[1..-1].downcase
+        start_filtered(options[:filters][name] || name)
       when DOCTYPE
         if line[0...3] == '!!!'
           render_doctype(line)
         else
-          push_text line
+          push_plain line
         end
       when ESCAPE
-        push_text line[1..-1]
+        push_plain line[1..-1]
       else
-        push_text line
+        push_plain line
       end
     end
     
@@ -307,20 +393,15 @@ module Haml
         @scope_object.instance_eval @precompiled
         @scope_object._haml_render &block
       rescue Exception => e
+        class << e
+          include Haml::Error
+        end
+
+        lineno = @scope_object.haml_lineno
+
         # 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
@@ -328,7 +409,7 @@ module Haml
           lineno = line_marker.scan(/[0-9]+/)[0].to_i if line_marker
         end
 
-        e.backtrace.unshift "#{filename}:#{lineno}"
+        e.add_backtrace_entry(lineno, @options[:filename])
         raise e
       end
 
@@ -340,9 +421,9 @@ module Haml
 
     # 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"
+    def push_silent(text, add_index = false)
+      if add_index
+        @precompiled << "@haml_lineno = #{@index}\n#{text}\n"
       else
         # Not really DRY, but probably faster
         @precompiled << "#{text}\n"
@@ -355,10 +436,24 @@ module Haml
       @precompiled << "_hamlout.push_text(#{text.dump}, #{@output_tabs})\n"
     end
 
+    # Renders a block of text as plain text.
+    # Also checks for an illegally opened block.
+    def push_plain(text)
+      if @block_opened
+        raise SyntaxError.new("Illegal Nesting: Nesting within plain text is illegal.")
+      end
+      push_text text
+    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"
+      tabulation = tabulation > -1 ? tabulation : 0
+      if @filter_buffer
+        @filter_buffer << "#{' ' * tabulation}#{text}\n"
+      else
+        @precompiled << "_hamlout.push_text(#{text.dump}, #{tabulation}, true)\n"
+      end
     end
 
     # Causes <tt>text</tt> to be evaluated in the context of
@@ -366,11 +461,11 @@ module Haml
     #
     # 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)
+    def push_script(text, flattened)
       unless options[:suppress_eval]
-        push_silent("haml_temp = #{text}", index)
+        push_silent("haml_temp = #{text}", true)
         out = "haml_temp = _hamlout.push_script(haml_temp, #{@output_tabs}, #{flattened})\n"
-        if block_opened
+        if @block_opened
           push_and_tabulate([:loud, out])
         else
           @precompiled << out
@@ -380,10 +475,13 @@ module Haml
     
     # 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)
+    def push_flat_script(text)
       unless text.empty?
-        push_script(text, true, block_opened, index)
+        push_script(text, true)
       else
+        unless @block_opened
+          raise SyntaxError.new('Filters must have nested text.')
+        end
         start_flat(false)
       end
     end
@@ -402,6 +500,8 @@ module Haml
         close_flat value
       when :loud
         close_loud value
+      when :filtered
+        close_filtered value
       end
     end
 
@@ -439,15 +539,40 @@ module Haml
     
     # Closes a loud Ruby block.
     def close_loud(command)
-      push_silent "end"
+      push_silent 'end'
       @precompiled << command
       @template_tabs -= 1
     end
 
+    # Closes a filtered block.
+    def close_filtered(filter)
+      @flat_spaces = -1
+      if filter.is_a? String
+        if filter == 'redcloth' || filter == 'markdown' || filter == 'textile'
+          raise HamlError.new("You must have the RedCloth gem installed to use #{filter}")
+        else
+          raise HamlError.new("Filter \"#{filter}\" is not defined!")
+        end
+      else
+        filtered = filter.new(@filter_buffer).render
+
+        unless filter == Haml::Filters::Preserve
+          push_text(filtered.rstrip.gsub("\n", "\n#{'  ' * @output_tabs}"))
+        else
+          push_silent("_hamlout.buffer << #{filtered.dump} << \"\\n\"\n")
+        end
+      end
+
+      @filter_buffer = nil
+      @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|
+    def render_tag(line)
+      matched = false
+      line.scan(TAG_REGEX) do |tag_name, attributes, attributes_hash, object_ref, action, value|
+        matched = true
         value = value.to_s
 
         case action
@@ -460,11 +585,24 @@ module Haml
         end
 
         flattened = (action == '~')
+        
+        warn(FLAT_WARNING) if flattened && !defined?(Test::Unit)
+
         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})"
+        if @block_opened 
+          if atomic
+            raise SyntaxError.new("Illegal Nesting: Nesting within an atomic tag is illegal.")
+          elsif action == '=' || value_exists
+            raise SyntaxError.new("Illegal Nesting: Nesting within a tag that already has content is illegal.")
+          end
+        elsif parse && !value_exists
+          raise SyntaxError.new("No tag content to parse.")
+        end
+
+        push_silent "_hamlout.open_tag(#{tag_name.inspect}, #{@output_tabs}, #{atomic.inspect}, #{value_exists.inspect}, #{attributes.inspect}, #{attributes_hash}, #{object_ref}, #{flattened.inspect})", true
 
         unless atomic
           push_and_tabulate([:element, tag_name])
@@ -472,7 +610,7 @@ module Haml
 
           if value_exists
             if parse
-              push_script(value, flattened, false, index)
+              push_script(value, flattened)
             else
               push_text(value)
             end
@@ -482,18 +620,27 @@ module Haml
           end
         end
       end
+
+      unless matched
+        raise SyntaxError.new("Invalid tag: \"#{line}\"")
+      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)
+    def render_div(line)
+      render_tag('%div' + line)
     end
 
     # Renders an XHTML comment.
     def render_comment(line)
-      conditional, content = line.scan(/\/(\[[a-zA-Z0-9 \.]*\])?(.*)/)[0]
-      content = content.strip
+      conditional, content = line.scan(COMMENT_REGEX)[0]
+      content.strip!
+
+      if @block_opened && !content.empty?
+        raise SyntaxError.new('Illegal Nesting: Nesting within a tag that already has content is illegal.')
+      end
+
       try_one_line = !content.empty?
       push_silent "_hamlout.open_comment(#{try_one_line}, #{conditional.inspect}, #{@output_tabs})"
       @output_tabs += 1
@@ -506,13 +653,16 @@ module Haml
     
     # Renders an XHTML doctype or XML shebang.
     def render_doctype(line)
+      if @block_opened
+        raise SyntaxError.new("Illegal Nesting: Nesting within a header command is illegal.")
+      end
       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]
+        version, type = line.scan(DOCTYPE_REGEX)[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
@@ -541,10 +691,23 @@ module Haml
       @flat_spaces = @template_tabs * 2
     end
 
+    # Starts a filtered block.
+    def start_filtered(filter)
+      unless @block_opened
+        raise SyntaxError.new('Filters must have nested text.')
+      end
+      push_and_tabulate([:filtered, filter])
+      @flat_spaces = @template_tabs * 2
+      @filter_buffer = String.new
+    end
+
     # Counts the tabulation of a line.
     def count_soft_tabs(line)
       spaces = line.index(/[^ ]/)
-      spaces ? [spaces, spaces/2] : []
+      if line[spaces] == ?\t
+        raise SyntaxError.new("Illegal Indentation: Only two space characters are allowed as tabulation.")
+      end
+      [spaces, spaces/2]
     end
     
     # Pushes value onto <tt>@to_close_stack</tt> and increases
@@ -555,3 +718,23 @@ module Haml
     end
   end
 end
+
+class Hash # :nodoc:
+  # Same as Hash#merge!, but recursively merges sub-hashes.
+  def rec_merge!(other)
+    other.each do |key, value|
+      myval = self[key]
+      if value.is_a?(Hash) && myval.is_a?(Hash)
+        myval.rec_merge!(value)
+      else
+        self[key] = value
+      end
+    end
+    self
+  end
+
+  def rec_merge(other)
+    toret = self.clone
+    toret.rec_merge! other
+  end
+end