haml 1.8.2 → 2.0.0

data/lib/haml/buffer.rb

@@ -6,11 +6,6 @@ module Haml
   class Buffer
     include Haml::Helpers
 
-    # Set the maximum length for a line to be considered a one-liner.
-    # Lines <= the maximum will be rendered on one line,
-    # i.e. <tt><p>Hello world</p></tt>
-    ONE_LINER_LENGTH     = 50
-
     # The string that holds the compiled XHTML. This is aliased as
     # _erbout for compatibility with ERB-specific code.
     attr_accessor :buffer
@@ -18,6 +13,47 @@ module Haml
     # The options hash passed in from Haml::Engine.
     attr_accessor :options
 
+    # The Buffer for the enclosing Haml document.
+    # This is set for partials and similar sorts of nested templates.
+    # It's nil at the top level (see #toplevel?).
+    attr_accessor :upper
+
+    # See #active?
+    attr_writer :active
+
+    # True if the format is XHTML
+    def xhtml?
+      not html?
+    end
+
+    # True if the format is any flavor of HTML
+    def html?
+      html4? or html5?
+    end
+
+    # True if the format is HTML4
+    def html4?
+      @options[:format] == :html4
+    end
+
+    # True if the format is HTML5
+    def html5?
+      @options[:format] == :html5
+    end
+
+    # True if this buffer is a top-level template,
+    # as opposed to a nested partial.
+    def toplevel?
+      upper.nil?
+    end
+
+    # True if this buffer is currently being used to render a Haml template.
+    # However, this returns false if a subtemplate is being rendered,
+    # even if it's a subtemplate of this buffer's template.
+    def active?
+      @active
+    end
+
     # Gets the current tabulation of the document.
     def tabulation
       @real_tabs + @tabulation
@@ -30,9 +66,13 @@ module Haml
     end
 
     # Creates a new buffer.
-    def initialize(options = {})
+    def initialize(upper = nil, options = {})
+      @active = true
+      @upper = upper
       @options = {
-        :attr_wrapper => "'"
+        :attr_wrapper => "'",
+        :ugly => false,
+        :format => :xhtml
       }.merge options
       @buffer = ""
       @tabulation = 0
@@ -44,56 +84,72 @@ module Haml
 
     # Renders +text+ with the proper tabulation. This also deals with
     # making a possible one-line tag one line or not.
-    def push_text(text, tab_change = 0)
-      if(@tabulation > 0)
-        # Have to push every line in by the extra user set tabulation
-        text.gsub!(/^/m, '  ' * @tabulation)
+    def push_text(text, dont_tab_up = false, tab_change = 0)
+      if @tabulation > 0 && !@options[:ugly]
+        # Have to push every line in by the extra user set tabulation.
+        # Don't push lines with just whitespace, though,
+        # because that screws up precompiled indentation.
+        text.gsub!(/^(?!\s+$)/m, tabs)
+        text.sub!(tabs, '') if dont_tab_up
       end
-      
-      @buffer << "#{text}"
+
+      @buffer << text
       @real_tabs += tab_change
+      @dont_tab_up_next_line = false
     end
 
     # Properly formats the output of a script that was run in the
     # instance_eval.
-    def push_script(result, flattened, close_tag = nil)
+    def push_script(result, preserve_script, in_tag = false, preserve_tag = false,
+                    escape_html = false, nuke_inner_whitespace = false)
       tabulation = @real_tabs
-      
-      if flattened
-        result = Haml::Helpers.find_and_preserve(result)
-      end
-      
-      result = result.to_s
-      while result[-1] == ?\n
-        # String#chomp is slow
-        result = result[0...-1]
+
+      if preserve_tag
+        result = Haml::Helpers.preserve(result)
+      elsif preserve_script
+        result = Haml::Helpers.find_and_preserve(result, options[:preserve])
       end
-      
-      if close_tag && Buffer.one_liner?(result)
+
+      result = result.to_s.rstrip
+      result = html_escape(result) if escape_html
+
+      has_newline = result.include?("\n")
+      if in_tag && (@options[:ugly] || !has_newline || preserve_tag)
         @buffer << result
-        @buffer << "</#{close_tag}>\n"
         @real_tabs -= 1
-      else
-        if close_tag
-          @buffer << "\n"
-        end
-        
-        result = result.gsub(/^/m, tabs(tabulation))
-        @buffer << "#{result}\n"
-        
-        if close_tag
-          @buffer << "#{tabs(tabulation-1)}</#{close_tag}>\n"
-          @real_tabs -= 1
-        end
+        return
+      end
+
+      @buffer << "\n" if in_tag && !nuke_inner_whitespace
+
+      # Precompiled tabulation may be wrong
+      if @tabulation > 0 && !in_tag
+        result = tabs + result
+      end
+
+      if has_newline && !@options[:ugly]
+        result = result.gsub "\n", "\n" + tabs(tabulation)
+
+        # Add tabulation if it wasn't precompiled
+        result = tabs(tabulation) + result if in_tag && !nuke_inner_whitespace
+      end
+      @buffer << "#{result}"
+      @buffer << "\n" unless nuke_inner_whitespace
+
+      if in_tag && !nuke_inner_whitespace
+        # We never get here if @options[:ugly] is true
+        @buffer << tabs(tabulation-1)
+        @real_tabs -= 1
       end
       nil
     end
 
     # Takes the various information about the opening tag for an
     # element, formats it, and adds it to the buffer.
-    def open_tag(name, atomic, try_one_line, class_id, obj_ref, content, *attributes_hashes)
+    def open_tag(name, self_closing, try_one_line, preserve_tag, escape_html, class_id,
+                 nuke_outer_whitespace, nuke_inner_whitespace, obj_ref, content, *attributes_hashes)
       tabulation = @real_tabs
-      
+
       attributes = class_id
       attributes_hashes.each do |attributes_hash|
         attributes_hash.keys.each { |key| attributes_hash[key.to_s] = attributes_hash.delete(key) }
@@ -101,23 +157,21 @@ module Haml
       end
       self.class.merge_attrs(attributes, parse_object_ref(obj_ref)) if obj_ref
 
-      if atomic
-        str = " />\n"
-      elsif try_one_line
-        str = ">"
+      if self_closing
+        str = " />" + (nuke_outer_whitespace ? "" : "\n")
       else
-        str = ">\n"
+        str = ">" + (try_one_line || preserve_tag || nuke_inner_whitespace ? "" : "\n")
       end
-      @buffer << "#{tabs(tabulation)}<#{name}#{Precompiler.build_attributes(@options[:attr_wrapper], attributes)}#{str}"
+
+      attributes = Precompiler.build_attributes(html?, @options[:attr_wrapper], attributes)
+      @buffer << "#{nuke_outer_whitespace || @options[:ugly] ? '' : tabs(tabulation)}<#{name}#{attributes}#{str}"
+
       if content
-        if Buffer.one_liner?(content)
-          @buffer << "#{content}</#{name}>\n"
-        else
-          @buffer << "\n#{tabs(@real_tabs+1)}#{content}\n#{tabs(@real_tabs)}</#{name}>\n"
-        end
-      elsif !atomic
-        @real_tabs += 1
+        @buffer << "#{content}</#{name}>" << (nuke_outer_whitespace ? "" : "\n")
+        return
       end
+
+      @real_tabs += 1 unless self_closing || nuke_inner_whitespace
     end
 
     def self.merge_attrs(to, from)
@@ -137,33 +191,33 @@ module Haml
       to.merge!(from)
     end
 
+    private
+
     # Some of these methods are exposed as public class methods
     # so they can be re-used in helpers.
 
-    # Returns whether or not the given value is short enough to be rendered
-    # on one line.
-    def self.one_liner?(value)
-      value.length <= ONE_LINER_LENGTH && value.scan(/\n/).empty?
-    end
-
-    private
-
     @@tab_cache = {}
     # Gets <tt>count</tt> tabs. Mostly for internal use.
-    def tabs(count)
+    def tabs(count = 0)
       tabs = count + @tabulation
-      '  ' * tabs
       @@tab_cache[tabs] ||= '  ' * tabs
     end
 
     # Takes an array of objects and uses the class and id of the first
     # one to create an attributes hash.
+    # The second object, if present, is used as a prefix,
+    # just like you can do with dom_id() and dom_class() in Rails
     def parse_object_ref(ref)
+      prefix = ref[1]
       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 = underscore(ref.class)
       id = "#{class_name}_#{ref.id || 'new'}"
+      if prefix
+        class_name = "#{ prefix }_#{ class_name}"
+        id = "#{ prefix }_#{ id }"
+      end
 
       {'id' => id, 'class' => class_name}
     end

data/lib/haml/engine.rb

@@ -3,7 +3,6 @@ require 'haml/buffer'
 require 'haml/precompiler'
 require 'haml/filters'
 require 'haml/error'
-require 'haml/util'
 
 module Haml
   # This is the class where all the parsing and processing of the Haml
@@ -24,57 +23,75 @@ module Haml
     # to produce the Haml document.
     attr :precompiled, true
 
+    # True if the format is XHTML
+    def xhtml?
+      not html?
+    end
+
+    # True if the format is any flavor of HTML
+    def html?
+      html4? or html5?
+    end
+
+    # True if the format is HTML4
+    def html4?
+      @options[:format] == :html4
+    end
+
+    # True if the format is HTML5
+    def html5?
+      @options[:format] == :html5
+    end
+
     # Creates a new instace of Haml::Engine that will compile the given
     # template string when <tt>render</tt> is called.
-    # See README for available options.
+    # See README.rdoc for available options.
     #
     #--
     # When adding options, remember to add information about them
-    # to README!
+    # to README.rdoc!
     #++
     #
     def initialize(template, options = {})
       @options = {
         :suppress_eval => false,
         :attr_wrapper => "'",
-        :autoclose => ['meta', 'img', 'link', 'br', 'hr', 'input', 'area'],
-        :filters => {
-          'sass' => Sass::Engine,
-          'plain' => Haml::Filters::Plain,
-          'preserve' => Haml::Filters::Preserve,
-          'redcloth' => Haml::Filters::RedCloth,
-          'textile' => Haml::Filters::Textile,
-          'markdown' => Haml::Filters::Markdown },
-        :filename => '(haml)'
-      }
-      @options.rec_merge! options
 
-      unless @options[:suppress_eval]
-        @options[:filters].merge!({
-          'erb' => ERB,
-          'ruby' => Haml::Filters::Ruby
-        })
-      end
-      @options[:filters].rec_merge! options[:filters] if options[:filters]
+        # Don't forget to update the docs in lib/haml.rb if you update these
+        :autoclose => %w[meta img link br hr input area param col base],
+        :preserve => %w[textarea pre],
 
-      if @options[:locals]
-        warn <<END
-DEPRECATION WARNING:
-The Haml :locals option is deprecated and will be removed in version 2.0.
-Use the locals option for Haml::Engine#render instead.
-END
+        :filename => '(haml)',
+        :line => 1,
+        :ugly => false,
+        :format => :xhtml,
+        :escape_html => false
+      }
+      @options.merge! options
+
+      unless [:xhtml, :html4, :html5].include?(@options[:format])
+        raise Haml::Error, "Invalid format #{@options[:format].inspect}"
       end
 
-      @template = template.strip #String
+      @template = template.rstrip #String
       @to_close_stack = []
       @output_tabs = 0
       @template_tabs = 0
       @index = 0
       @flat_spaces = -1
+      @newlines = 0
+
+      if @options[:filters]
+        warn <<END
+DEPRECATION WARNING:
+The Haml :filters option is deprecated and will be removed in version 2.1.
+Filters are now automatically registered.
+END
+      end
 
       precompile
     rescue Haml::Error
-      $!.backtrace.unshift "#{@options[:filename]}:#{@index}"
+      $!.backtrace.unshift "#{@options[:filename]}:#{@index + $!.line_offset + @options[:line] - 1}" if @index
       raise
     end
 
@@ -84,7 +101,7 @@ END
     # If it's a Binding or Proc object,
     # Haml uses it as the second argument to Kernel#eval;
     # otherwise, Haml just uses its #instance_eval context.
-    # 
+    #
     # Note that Haml modifies the evaluation context
     # (either the scope object or the "self" object of the scope binding).
     # It extends Haml::Helpers, and various instance variables are set
@@ -114,8 +131,7 @@ END
     # but if you're relying on local variables defined in the context of scope,
     # they won't work.
     def render(scope = Object.new, locals = {}, &block)
-      locals = (@options[:locals] || {}).merge(locals)
-      buffer = Haml::Buffer.new(options_for_buffer)
+      buffer = Haml::Buffer.new(scope.instance_variable_get('@haml_buffer'), options_for_buffer)
 
       if scope.is_a?(Binding) || scope.is_a?(Proc)
         scope_object = eval("self", scope)
@@ -129,17 +145,14 @@ END
 
       scope_object.instance_eval do
         extend Haml::Helpers
-        @haml_stack ||= Array.new
-        @haml_stack.push(buffer)
-        @haml_is_haml = true
+        @haml_buffer = buffer
       end
 
-      eval(@precompiled, scope, @options[:filename], 0)
+      eval(@precompiled, scope, @options[:filename], @options[:line])
 
       # Get rid of the current buffer
       scope_object.instance_eval do
-        @haml_stack.pop
-        @haml_is_haml = false
+        @haml_buffer = buffer.upper
       end
 
       buffer.buffer
@@ -176,7 +189,7 @@ END
       end
 
       eval("Proc.new { |*_haml_locals| _haml_locals = _haml_locals[0] || {};" +
-           precompiled_with_ambles(local_names) + "}\n", scope, @options[:filename], 0)
+           precompiled_with_ambles(local_names) + "}\n", scope, @options[:filename], @options[:line])
     end
 
     # Defines a method on +object+
@@ -193,7 +206,7 @@ END
     #
     #   Haml::Engine.new(".upcased= upcase").def_method(String, :upcased_div)
     #   "foobar".upcased_div #=> "<div class='upcased'>FOOBAR</div>\n"
-    # 
+    #
     # The first argument of the defined method is a hash of local variable names to values.
     # However, due to an unfortunate Ruby quirk,
     # the local variables which can be assigned must be pre-declared.
@@ -209,7 +222,7 @@ END
     #   obj = Object.new
     #   Haml::Engine.new("%p= foo").def_method(obj, :render)
     #   obj.render(:foo => "Hello!") #=> NameError: undefined local variable or method `foo'
-    # 
+    #
     # Note that Haml modifies the evaluation context
     # (either the scope object or the "self" object of the scope binding).
     # It extends Haml::Helpers, and various instance variables are set
@@ -218,7 +231,7 @@ END
       method = object.is_a?(Module) ? :module_eval : :instance_eval
 
       object.send(method, "def #{name}(_haml_locals = {}); #{precompiled_with_ambles(local_names)}; end",
-                  @options[:filename], 0)
+                  @options[:filename], @options[:line])
     end
 
     private
@@ -230,9 +243,15 @@ END
     end
 
     # Returns a hash of options that Haml::Buffer cares about.
-    # This should remain loadable form #inspect.
+    # This should remain loadable from #inspect.
     def options_for_buffer
-      {:attr_wrapper => @options[:attr_wrapper]}
+      {
+        :autoclose => @options[:autoclose],
+        :preserve => @options[:preserve],
+        :attr_wrapper => @options[:attr_wrapper],
+        :ugly => @options[:ugly],
+        :format => @options[:format]
+      }
     end
   end
 end