haml 2.0.0 → 2.0.1

data/REVISION

@@ -0,0 +1 @@
+(release)

data/Rakefile

@@ -19,7 +19,9 @@ require 'rake/testtask'
 
 Rake::TestTask.new do |t|
   t.libs << 'lib'
-  t.pattern = 'test/**/*_test.rb'
+  test_files = FileList['test/**/*_test.rb']
+  test_files.exclude('test/rails/*')
+  t.test_files = test_files
   t.verbose = true
 end
 Rake::Task[:test].send(:add_comment, <<END)
@@ -53,13 +55,15 @@ end
 Rake::Task[:package].prerequisites.insert(0, :revision_file)
 
 # We also need to get rid of this file after packaging.
-Rake::Task[:package].enhance { File.delete('REVISION') if File.exists?('REVISION') }
+at_exit { File.delete('REVISION') rescue nil }
 
+desc "Install Haml as a gem."
 task :install => [:package] do
   sudo = RUBY_PLATFORM =~ /win32/ ? '' : 'sudo'
   sh %{#{sudo} gem install --no-ri pkg/haml-#{File.read('VERSION').strip}}
 end
 
+desc "Release a new Haml package to Rubyforge. Requires the NAME and VERSION flags."
 task :release => [:package] do
   name, version = ENV['NAME'], ENV['VERSION']
   raise "Must supply NAME and VERSION for release task." unless name && version

data/VERSION

@@ -1 +1 @@
-2.0.0
+2.0.1

data/lib/haml.rb

@@ -914,9 +914,16 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir)
 #
 # === Haml Options
 #
-# Options can be set by setting the hash <tt>Haml::Template.options</tt>
-# from <tt>environment.rb</tt> in Rails,
-# or by passing an options hash to Haml::Engine.
+# Options can be set by setting the <tt>Haml::Template.options</tt> hash
+# in <tt>environment.rb</tt> in Rails...
+#
+#   Haml::Template.options[:output] = :html5
+#
+# ...or by setting the <tt>Merb::Config[:haml]</tt> hash in <tt>init.rb</tt> in Merb...
+#
+#   Merb::Config[:haml][:output] = :html5
+# 
+# ...or by passing an options hash to Haml::Engine.new.
 # Available options are:
 #
 # [<tt>:output</tt>]        Determines the output format. The default is :xhtml.
@@ -927,7 +934,8 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir)
 # [<tt>:escape_html</tt>]   Sets whether or not to escape HTML-sensitive characters in script.
 #                           If this is true, = behaves like &=;
 #                           otherwise, it behaves like !=.
-#                           <b>Note that this escapes tag attributes.</b>
+#                           Note that if this is set, != should be used for yielding to subtemplates
+#                           and rendering partials.
 #                           Defaults to false.
 #
 # [<tt>:suppress_eval</tt>] Whether or not attribute hashes and Ruby scripts

data/lib/haml/buffer.rb

@@ -114,7 +114,7 @@ module Haml
       result = html_escape(result) if escape_html
 
       has_newline = result.include?("\n")
-      if in_tag && (@options[:ugly] || !has_newline || preserve_tag)
+      if in_tag && !nuke_inner_whitespace && (@options[:ugly] || !has_newline || preserve_tag)
         @buffer << result
         @real_tabs -= 1
         return
@@ -199,7 +199,7 @@ module Haml
     @@tab_cache = {}
     # Gets <tt>count</tt> tabs. Mostly for internal use.
     def tabs(count = 0)
-      tabs = count + @tabulation
+      tabs = [count + @tabulation, 0].max
       @@tab_cache[tabs] ||= '  ' * tabs
     end
 

data/lib/haml/engine.rb

@@ -45,11 +45,11 @@ module Haml
 
     # Creates a new instace of Haml::Engine that will compile the given
     # template string when <tt>render</tt> is called.
-    # See README.rdoc for available options.
+    # See the Haml module documentation for available options.
     #
     #--
     # When adding options, remember to add information about them
-    # to README.rdoc!
+    # to lib/haml.rb!
     #++
     #
     def initialize(template, options = {})
@@ -73,13 +73,20 @@ module Haml
         raise Haml::Error, "Invalid format #{@options[:format].inspect}"
       end
 
-      @template = template.rstrip #String
+      @template = template.rstrip + "\n-#\n-#"
       @to_close_stack = []
       @output_tabs = 0
       @template_tabs = 0
       @index = 0
       @flat_spaces = -1
       @newlines = 0
+      @precompiled = ''
+      @merged_text = ''
+      @tab_change  = 0
+
+      if @template =~ /\A(\s*\n)*[ \t]+\S/
+        raise SyntaxError.new("Indenting at the beginning of the document is illegal.", ($1 || "").count("\n"))
+      end
 
       if @options[:filters]
         warn <<END
@@ -90,8 +97,8 @@ END
       end
 
       precompile
-    rescue Haml::Error
-      $!.backtrace.unshift "#{@options[:filename]}:#{@index + $!.line_offset + @options[:line] - 1}" if @index
+    rescue Haml::Error => e
+      e.backtrace.unshift "#{@options[:filename]}:#{(e.line ? e.line + 1 : @index) + @options[:line] - 1}" if @index
       raise
     end
 

data/lib/haml/error.rb

@@ -5,13 +5,12 @@ module Haml
 
     # By default, an error is taken to refer to the line of the template
     # that was being processed when the exception was raised.
-    # However, if line_offset is non-zero, it's added to that line number
-    # to get the line to report for the error.
-    attr_reader :line_offset
+    # However, if line is non-nil, it + 1 is used instead.
+    attr_reader :line
 
-    def initialize(message = nil, line_offset = 0)
+    def initialize(message = nil, line = nil)
       super(message)
-      @line_offset = line_offset
+      @line = line
     end
     # :startdoc:
   end

data/lib/haml/exec.rb

@@ -1,5 +1,6 @@
 require File.dirname(__FILE__) + '/../haml'
 require 'optparse'
+require 'fileutils'
 
 module Haml
   # This module contains code for working with the
@@ -128,8 +129,9 @@ END
           dir = File.join(dir, 'haml')
 
           if File.exists?(dir)
-            puts "Directory #{dir} already exists."
-            exit
+            print "Directory #{dir} already exists, overwrite [y/N]? "
+            exit if gets !~ /y/i
+            FileUtils.rm_rf(dir)
           end
 
           begin

data/lib/haml/helpers.rb

@@ -265,8 +265,8 @@ module Haml
 
     #
     # call-seq:
-    #   haml_tag(name, attributes = {}) {...}
-    #   haml_tag(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
@@ -274,6 +274,11 @@ module Haml
     # 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,
     #
     #   haml_tag :table do
@@ -304,34 +309,46 @@ module Haml
     #     </tr>
     #   </table>
     #
-    def haml_tag(name, attributes = {}, alt_atts = {}, &block)
+    def haml_tag(name, *rest, &block)
       name = name.to_s
+      text = rest.shift if rest.first.is_a? String
+      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? && (haml_buffer.options[:autoclose].include?(name) || flags.include?(:/))
+        puts "<#{name}#{attributes} />"
+        return nil
+      end
 
-      text = nil
-      if attributes.is_a? String
-        text = attributes
-        attributes = alt_atts
+      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
 
-      attributes = Haml::Precompiler.build_attributes(
-        haml_buffer.html?, haml_buffer.options[:attr_wrapper], attributes)
+      tag = "<#{name}#{attributes}>"
+      if block.nil?
+        tag << text.to_s << "</#{name}>"
+        puts tag
+        return
+      end
 
-      if text.nil? && block.nil? && haml_buffer.options[:autoclose].include?(name)
-        puts "<#{name}#{attributes} />"
-        return nil
+      if text
+        raise Error.new("Illegal nesting: content can't be both given to haml_tag :#{name} and nested within it.")
       end
 
-      puts "<#{name}#{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?(:<)
+        tag << capture_haml(&block).strip << "</#{name}>"
+        puts tag
+        return
       end
+
+      puts tag
+      tab_up
+      block.call
+      tab_down
       puts "</#{name}>"
       nil
     end

data/lib/haml/helpers/action_view_mods.rb

@@ -7,56 +7,93 @@ if defined?(ActionView) and not defined?(Merb::Plugins)
       end
       alias_method :render_without_haml, :render
       alias_method :render, :render_with_haml
+
+      # Rails >2.1
+      if instance_methods.include?('output_buffer')
+        def output_buffer_with_haml
+          return haml_buffer.buffer if is_haml?
+          output_buffer_without_haml
+        end
+        alias_method :output_buffer_without_haml, :output_buffer
+        alias_method :output_buffer, :output_buffer_with_haml
+
+        def set_output_buffer_with_haml(new)
+          if is_haml?
+            haml_buffer.buffer = new
+          else
+            set_output_buffer_without_haml new
+          end
+        end
+        alias_method :set_output_buffer_without_haml, :output_buffer=
+        alias_method :output_buffer=, :set_output_buffer_with_haml
+      end
     end
 
     # This overrides various helpers in ActionView
     # to make them work more effectively with Haml.
     module Helpers
       # :stopdoc:
-      module CaptureHelper
-        def capture_with_haml(*args, &block)
-          # Rails' #capture helper will just return the value of the block
-          # if it's not actually in the template context,
-          # as detected by the existance of an _erbout variable.
-          # We've got to do the same thing for compatibility.
-          block_is_haml =
-            begin
-              eval('_hamlout', block)
-              true
-            rescue
-              false
+      # In Rails <=2.1, we've got to override considerable capturing infrastructure.
+      # In Rails >2.1, we can make do with only overriding #capture
+      # (which no longer behaves differently in helper contexts).
+      unless ActionView::Base.instance_methods.include?('output_buffer')
+        module CaptureHelper
+          def capture_with_haml(*args, &block)
+            # Rails' #capture helper will just return the value of the block
+            # if it's not actually in the template context,
+            # as detected by the existance of an _erbout variable.
+            # We've got to do the same thing for compatibility.
+            block_is_haml =
+              begin
+                eval('_hamlout', block)
+                true
+              rescue
+                false
+              end
+
+            if block_is_haml && is_haml?
+              capture_haml(*args, &block)
+            else
+              capture_without_haml(*args, &block)
             end
+          end
+          alias_method :capture_without_haml, :capture
+          alias_method :capture, :capture_with_haml
 
-          if block_is_haml && is_haml?
-            capture_haml(*args, &block)
-          else
-            capture_without_haml(*args, &block)
+          def capture_erb_with_buffer_with_haml(*args, &block)
+            if is_haml?
+              capture_haml_with_buffer(*args, &block)
+            else
+              capture_erb_with_buffer_without_haml(*args, &block)
+            end
           end
+          alias_method :capture_erb_with_buffer_without_haml, :capture_erb_with_buffer
+          alias_method :capture_erb_with_buffer, :capture_erb_with_buffer_with_haml
         end
-        alias_method :capture_without_haml, :capture
-        alias_method :capture, :capture_with_haml
 
-        def capture_erb_with_buffer_with_haml(*args, &block)
-          if is_haml?
-            capture_haml_with_buffer(*args, &block)
-          else
-            capture_erb_with_buffer_without_haml(*args, &block)
+        module TextHelper
+          def concat_with_haml(string, binding = nil)
+            if is_haml?
+              haml_buffer.buffer.concat(string)
+            else
+              concat_without_haml(string, binding)
+            end
           end
+          alias_method :concat_without_haml, :concat
+          alias_method :concat, :concat_with_haml
         end
-        alias_method :capture_erb_with_buffer_without_haml, :capture_erb_with_buffer
-        alias_method :capture_erb_with_buffer, :capture_erb_with_buffer_with_haml
-      end
-
-      module TextHelper
-        def concat_with_haml(string, binding = nil)
-          if is_haml?
-            haml_buffer.buffer.concat(string)
-          else
-            concat_without_haml(string, binding)
+      else
+        module CaptureHelper
+          def capture_with_haml(*args, &block)
+            if is_haml?
+              capture_haml(*args, &block)
+            else
+              capture_without_haml(*args, &block)
+            end
           end
+          alias_method :capture_without_haml, :capture
+          alias_method :capture, :capture_with_haml
         end
-        alias_method :concat_without_haml, :concat
-        alias_method :concat, :concat_with_haml
       end
 
       module TagHelper

data/lib/haml/precompiler.rb

@@ -109,28 +109,15 @@ END
       end.join(';') + ';'
     end
 
-    Line = Struct.new("Line", :text, :unstripped, :index, :spaces, :tabs)
+    Line = Struct.new(:text, :unstripped, :index, :spaces, :tabs)
 
     def precompile
-      @precompiled = ''
-      @merged_text = ''
-      @tab_change  = 0
-
       old_line = Line.new
-      (@template + "\n-#\n-#").split(/\r\n|\r|\n/).each_with_index do |text, index|
-        line = Line.new text.strip, text.lstrip.chomp, index
+      @template.split(/\r\n|\r|\n/).each_with_index do |text, index|
+        @next_line = line = Line.new(text.strip, text.lstrip.chomp, index)
         line.spaces, line.tabs = count_soft_tabs(text)
 
-        if line.text.empty?
-          process_indent(old_line) if flat? && !old_line.text.empty?
-
-          unless flat?
-            newline
-            next
-          end
-
-          push_flat(old_line)
-          old_line.text, old_line.unstripped, old_line.spaces = '', '', 0
+        if line.text.empty? && !flat?
           newline
           next
         end
@@ -154,7 +141,7 @@ END
         end
 
         if old_line.spaces != old_line.tabs * 2
-          raise SyntaxError.new(<<END.strip, 1 + old_line.index - @index)
+          raise SyntaxError.new(<<END.strip, old_line.index)
 #{old_line.spaces} space#{old_line.spaces == 1 ? ' was' : 's were'} used for indentation. Haml must be indented using two spaces.
 END
         end
@@ -165,7 +152,7 @@ END
         resolve_newlines
 
         if !flat? && line.tabs - old_line.tabs > 1
-          raise SyntaxError.new(<<END.strip, 2 + old_line.index - @index)
+          raise SyntaxError.new(<<END.strip, line.index)
 #{line.spaces} spaces were used for indentation. Haml must be indented using two spaces.
 END
         end
@@ -307,7 +294,10 @@ END
     # Renders a block of text as plain text.
     # Also checks for an illegally opened block.
     def push_plain(text)
-      raise SyntaxError.new("Illegal nesting: nesting within plain text is illegal.", 1) if @block_opened
+      if @block_opened
+        raise SyntaxError.new("Illegal nesting: nesting within plain text is illegal.", @next_line.index)
+      end
+
       push_text text
     end
 
@@ -545,6 +535,7 @@ END
 
       preserve_tag = options[:preserve].include?(tag_name)
       nuke_inner_whitespace ||= preserve_tag
+      preserve_tag &&= !options[:ugly]
 
       case action
       when '/'; self_closing = xhtml?
@@ -573,8 +564,8 @@ END
       attributes = parse_class_and_id(attributes)
       Buffer.merge_attrs(attributes, static_attributes) if static_attributes
 
-      raise SyntaxError.new("Illegal nesting: nesting within a self-closing tag is illegal.", 1) if @block_opened && self_closing
-      raise SyntaxError.new("Illegal nesting: content can't be both given on the same line as %#{tag_name} and nested within it.", 1) if @block_opened && !value.empty?
+      raise SyntaxError.new("Illegal nesting: nesting within a self-closing tag is illegal.", @next_line.index) if @block_opened && self_closing
+      raise SyntaxError.new("Illegal nesting: content can't be both given on the same line as %#{tag_name} and nested within it.", @next_line.index) if @block_opened && !value.empty?
       raise SyntaxError.new("There's no Ruby code for #{action} to evaluate.") if parse && value.empty?
       raise SyntaxError.new("Self-closing tags can't have content.") if self_closing && !value.empty?
 
@@ -641,7 +632,7 @@ END
       conditional << ">" if conditional
 
       if @block_opened && !line.empty?
-        raise SyntaxError.new('Illegal nesting: nesting within a tag that already has content is illegal.', 1)
+        raise SyntaxError.new('Illegal nesting: nesting within a tag that already has content is illegal.', @next_line.index)
       end
 
       open = "<!--#{conditional} "
@@ -662,7 +653,7 @@ END
 
     # Renders an XHTML doctype or XML shebang.
     def render_doctype(line)
-      raise SyntaxError.new("Illegal nesting: nesting within a header command is illegal.", 1) if @block_opened
+      raise SyntaxError.new("Illegal nesting: nesting within a header command is illegal.", @next_line.index) if @block_opened
       doctype = text_for_doctype(line)
       push_text doctype if doctype
     end
@@ -758,8 +749,8 @@ END
     def count_soft_tabs(line)
       spaces = line.index(/([^ ]|$)/)
       if line[spaces] == ?\t
-        return nil if line.strip.empty?
-        raise SyntaxError.new(<<END.strip, 2)
+        return 0, 0 if line.strip.empty?
+        raise SyntaxError.new(<<END.strip, @next_line.index)
 A tab character was used for indentation. Haml must be indented using two spaces.
 Are you sure you have soft tabs enabled in your editor?
 END