haml 1.7.2 → 1.8.0

data/lib/sass/tree/attr_node.rb

@@ -9,7 +9,7 @@ module Sass::Tree
       super(value, style)
     end
     
-    def to_s(parent_name = nil)
+    def to_s(tabs, parent_name = nil)
       if value[-1] == ?;
         raise Sass::SyntaxError.new("Invalid attribute: #{declaration.dump} (This isn't CSS!)", @line)
       end
@@ -20,21 +20,22 @@ module Sass::Tree
         raise Sass::SyntaxError.new("Invalid attribute: #{declaration.dump}", @line)
       end
 
-      join_string = @style == :compact ? ' ' : "\n"
+      join_string = case @style
+                    when :compact; ' '
+                    when :compressed; ''
+                    else "\n"
+                    end
+      spaces = '  ' * (tabs - 1)
       to_return = ''
       if !value.empty?
-        to_return << "#{real_name}: #{value};#{join_string}"
+        to_return << "#{spaces}#{real_name}:#{@style == :compressed ? '' : ' '}#{value};#{join_string}"
       end
 
       children.each do |kid|
-        if @style == :compact
-          to_return << "#{kid.to_s(real_name)} "
-        else
-          to_return << "#{kid.to_s(real_name)}\n"
-        end
+        to_return << "#{kid.to_s(tabs, real_name)}" << join_string
       end
-      to_return << "\n" unless children.empty? || @style == :compact
-      to_return[0...-1]
+            
+      (@style == :compressed && parent_name) ? to_return : to_return[0...-1]
     end
 
     private
@@ -44,7 +45,7 @@ module Sass::Tree
     end
 
     def invalid_child?(child)
-      if !child.is_a?(AttrNode)
+      if !child.is_a?(AttrNode) && !child.is_a?(CommentNode)
         "Illegal nesting: Only attributes may be nested beneath attributes."
       end
     end

data/lib/sass/tree/comment_node.rb

@@ -6,9 +6,15 @@ module Sass::Tree
       super(value[2..-1].strip, style)
     end
 
-    def to_s(parent_name = nil)
-      join_string = @style == :compact ? ' ' : "\n * "
-      "/* #{value}#{join_string unless children.empty?}#{children.join join_string} */"
+    def to_s(tabs = 0, parent_name = nil)
+      return if @style == :compressed
+
+      spaces = '  ' * (tabs - 1)
+      join_string = @style == :compact ? ' ' : "\n#{spaces} * "
+      str = "#{spaces}/* #{value}"
+      str << join_string unless children.empty?
+      str << "#{children.join join_string} */"
+      str
     end
   end
 end

data/lib/sass/tree/directive_node.rb

@@ -0,0 +1,51 @@
+require 'sass/tree/node'
+require 'sass/tree/value_node'
+
+module Sass::Tree
+  class DirectiveNode < ValueNode
+    def to_s(tabs)
+      if children.empty?
+        value + ";"
+      else
+        result = if @style == :compressed
+                   "#{value}{"
+                 else
+                   "#{'  ' * (tabs - 1)}#{value} {" + (@style == :compact ? ' ' : "\n")
+                 end
+        was_attr = false
+        first = true
+        children.each do |child|
+          if child.is_a?(RuleNode) && child.continued?
+            check_multiline_rule(child)
+            continued_rule = true
+          end
+
+          if @style == :compact
+            if child.is_a?(AttrNode)
+              result << "#{child.to_s(first || was_attr ? 1 : tabs + 1)} "
+            else
+              if was_attr
+                result[-1] = "\n"
+              end
+              rendered = child.to_s(tabs + 1)
+              rendered.lstrip! if first
+              result << rendered
+            end
+            was_attr = child.is_a?(AttrNode)
+            first = continued_rule
+          elsif @style == :compressed
+            result << (was_attr ? ";#{child.to_s(1)}" : child.to_s(1))
+            was_attr = child.is_a?(AttrNode)
+          else
+            result << child.to_s(tabs + 1) + (continued_rule ? '' : "\n")
+          end
+        end
+        result.rstrip + if @style == :compressed
+                          "}"
+                        else
+                          (@style == :expanded ? "\n" : " ") + "}\n"
+                        end
+      end
+    end
+  end
+end

data/lib/sass/tree/node.rb

@@ -22,15 +22,22 @@ module Sass
         children.each do |child|
           if child.is_a? AttrNode
             raise SyntaxError.new('Attributes aren\'t allowed at the root of a document.', child.line)
+          elsif child.is_a?(RuleNode) && child.continued?
+            check_multiline_rule(child)
+            result << child.to_s(1)
+          else
+            result << "#{child.to_s(1)}" + (@style == :compressed ? '' : "\n")
           end
+        end
+        @style == :compressed ? result+"\n" : result[0...-1]
+      end
 
-          begin
-            result += "#{child.to_s(1)}\n"
-          rescue SyntaxError => e
-            raise e
-          end
+      protected
+
+      def check_multiline_rule(rule)
+        unless rule.children.empty?
+          raise SyntaxError.new('Rules can\'t end in commas.', rule.line)
         end
-        result[0...-1]
       end
 
       private

data/lib/sass/tree/rule_node.rb

@@ -8,10 +8,18 @@ module Sass::Tree
 
     alias_method :rule, :value
     alias_method :rule=, :value=
+
+    def continued?
+      rule[-1] == ?,
+    end
     
     def to_s(tabs, super_rules = nil)
       attributes = []
       sub_rules = []
+
+      # Save this because the comma's removed by the super_rule additions
+      was_continued = continued?
+
       total_rule = if super_rules
         super_rules.split(/,\s*/).collect! do |s|
           self.rule.split(/,\s*/).collect do |r|
@@ -21,7 +29,7 @@ module Sass::Tree
               "#{s} #{r}"
             end
           end.join(", ")
-        end.join(", ")
+        end.join(", ") + (was_continued ? ',' : '')
       elsif self.rule.include?(PARENT)
         raise Sass::SyntaxError.new("Base-level rules cannot contain the parent-selector-referencing character '#{PARENT}'", line)
       else
@@ -37,22 +45,36 @@ module Sass::Tree
       end
       
       to_return = ''
-      unless attributes.empty?
+      if !attributes.empty?
+        old_spaces = '  ' * (tabs - 1)
+        spaces = '  ' * tabs
         if @style == :compact
-          to_return << "#{total_rule} { #{attributes.join(' ')} }\n"
+          attributes = attributes.map { |a| a.to_s(1) }.join(' ')
+          to_return << "#{old_spaces}#{total_rule} { #{attributes} }\n"
+        elsif @style == :compressed
+          attributes = attributes.map { |a| a.to_s(1) }.join(';')
+          to_return << "#{total_rule}{#{attributes}}"
         else
-          spaces = (@style == :expanded ? 2 : tabs * 2)
-          old_spaces = ' ' * (spaces - 2)
-          spaces = ' ' * spaces
-
-          attributes = attributes.join("\n").gsub("\n", "\n#{spaces}").rstrip
-          end_attrs = (@style == :expanded ? "\n" : ' ')
-          to_return << "#{old_spaces}#{total_rule} {\n#{spaces}#{attributes}#{end_attrs}}\n"
+          attributes = attributes.map { |a| a.to_s(tabs + 1) }.join("\n")
+          end_attrs = (@style == :expanded ? "\n" + old_spaces : ' ')
+          to_return << "#{old_spaces}#{total_rule} {\n#{attributes}#{end_attrs}}\n"
         end
+      elsif continued?
+        to_return << ('  ' * (tabs - 1)) + total_rule + case @style
+                                                        when :compressed; ''
+                                                        when :compact; ' '
+                                                        else "\n"
+                                                        end
       end
       
-      tabs += 1 unless attributes.empty?
-      sub_rules.each { |sub| to_return << sub.to_s(tabs, total_rule) }
+      tabs += 1 unless attributes.empty? || @style != :nested
+      sub_rules.each do |sub|
+        if sub.continued?
+          check_multiline_rule(sub)
+        end
+
+        to_return << sub.to_s(tabs, total_rule)
+      end
       to_return
     end
   end

data/test/benchmark.rb

@@ -1,62 +1,95 @@
-require 'rubygems'
-require 'active_support'
-require 'action_controller'
-require 'action_view'
-
-require File.dirname(__FILE__) + '/../lib/haml'
-require 'haml/template'
-require 'sass/engine'
+# There's a bizarre error where ActionController tries to load a benchmark file
+# and ends up finding this.
+# These declarations then cause it to break.
+# This only happens when running rcov, though, so we can avoid it.
+unless $0 =~ /rcov$/
+  require File.dirname(__FILE__) + '/../lib/haml'
+  require 'haml'
+end
 
+require 'rubygems'
+require 'erb'
+require 'erubis'
+require 'markaby'
 require 'benchmark'
 require 'stringio'
+require 'open-uri'
 
 module Haml
-  class Benchmarker
-  
-    # Creates a new benchmarker that looks for templates in the base
-    # directory.
-    def initialize(base = File.dirname(__FILE__))
-      ActionView::Base.register_template_handler("haml", Haml::Template)
-      unless base.class == ActionView::Base
-        @base = ActionView::Base.new(base)
-      else
-        @base = base
-      end
+  # Benchmarks Haml against ERB, Erubis, and Markaby and Sass on its own.
+  def self.benchmark(runs = 100)
+    template_name = 'standard'
+    directory = File.dirname(__FILE__) + '/haml'
+    haml_template =    File.read("#{directory}/templates/#{template_name}.haml")
+    erb_template =   File.read("#{directory}/rhtml/#{template_name}.rhtml")
+    markaby_template = File.read("#{directory}/markaby/#{template_name}.mab")
+
+    puts '-'*51, "Haml and Friends: No Caching", '-'*51
+
+    times = Benchmark.bmbm do |b|
+      b.report("haml:")   { runs.times { Haml::Engine.new(haml_template).render } }
+      b.report("erb:")    { runs.times { ERB.new(erb_template, nil, '-').render } }
+      b.report("erubis:") { runs.times { Erubis::Eruby.new(erb_template).result } }
+      b.report("mab:")    { runs.times { Markaby::Template.new(markaby_template).render } }
+    end
+
+    print_result = proc do |s, n|
+      printf "%1$*2$s %3$*4$g",
+        "Haml/#{s}:", -13, times[0].to_a[5] / times[n].to_a[5], -17
+      printf "%1$*2$s %3$g\n",
+        "#{s}/Haml:", -13, times[n].to_a[5] / times[0].to_a[5]
+    end
+    
+    print_result["ERB", 1]
+    print_result["Erubis", 2]
+    print_result["Markaby", 3]
+
+    puts '', '-' * 50, 'Haml and Friends: Cached', '-' * 50
+
+    obj = Object.new
+    Haml::Engine.new(haml_template).def_method(obj, :haml)
+    erb = ERB.new(erb_template, nil, '-')
+    obj.instance_eval("def erb; #{erb.src}; end")
+    Erubis::Eruby.new(erb_template).def_method(obj, :erubis)
+    times = Benchmark.bmbm do |b|
+      b.report("haml:")   { runs.times { obj.haml      } }
+      b.report("erb:")    { runs.times { obj.erb       } }
+      b.report("erubis:") { runs.times { obj.erubis    } }
+    end    
+
+    print_result["ERB", 1]
+    print_result["Erubis", 2]
+
+    puts '', '-' * 50, 'Haml and ERB: Via ActionView', '-' * 50
+
+    require 'active_support'
+    require 'action_controller'
+    require 'action_view'
+    require 'haml/template'
+
+    @base = ActionView::Base.new(File.dirname(__FILE__))
+    times = Benchmark.bmbm do |b|
+      b.report("haml:") { runs.times { @base.render 'haml/templates/standard' } }
+      b.report("erb:")  { runs.times { @base.render 'haml/rhtml/standard'     } }
     end
+
+    print_result["ERB", 1]
+
+    puts '', '-' * 50, 'Haml and ERB: Via ActionView with deep partials', '-' * 50
+
+    @base = ActionView::Base.new(File.dirname(__FILE__))
+    times = Benchmark.bmbm do |b|
+      b.report("haml:") { runs.times { @base.render 'haml/templates/action_view' } }
+      b.report("erb:")  { runs.times { @base.render 'haml/rhtml/action_view'     } }
+    end
+
+    print_result["ERB", 1]
+    
+    puts '', '-' * 50, 'Sass', '-' * 50
+    sass_template = File.read("#{File.dirname(__FILE__)}/sass/templates/complex.sass")
     
-    # Benchmarks haml against ERb, and Sass on its own.
-    # 
-    # Returns the results of the benchmarking as a string.
-    # 
-    def benchmark(runs = 100)
-      template_name = 'standard'
-      haml_template = "haml/templates/#{template_name}"
-      rhtml_template = "haml/rhtml/#{template_name}"
-      sass_template = File.dirname(__FILE__) + "/sass/templates/complex.sass"
-      
-      old_stdout = $stdout
-      $stdout = StringIO.new
-      
-      times = Benchmark.bmbm do |b|
-        b.report("haml:") { runs.times { @base.render haml_template } }
-        b.report("erb:") { runs.times { @base.render rhtml_template } }
-      end
-      
-      #puts times[0].inspect, times[1].inspect
-      ratio = sprintf("%g", times[0].to_a[5] / times[1].to_a[5])
-      puts "Haml/ERB: " + ratio
-      
-      puts '', '-' * 50, 'Sass on its own', '-' * 50
-      
-      Benchmark.bmbm do |b|
-        b.report("sass:") { runs.times { Sass::Engine.new(File.read(sass_template)).render } }
-      end
-      
-      $stdout.pos = 0
-      to_return = $stdout.read
-      $stdout = old_stdout
-      
-      to_return
+    Benchmark.bmbm do |b|
+      b.report("sass:") { runs.times { Sass::Engine.new(sass_template).render } }
     end
   end
 end

data/test/haml/engine_test.rb

@@ -11,21 +11,18 @@ require 'haml/engine'
 
 class EngineTest < Test::Unit::TestCase
 
-  def render(text, options = {})
-    Haml::Engine.new(text, options).to_html
+  def render(text, options = {}, &block)
+    scope  = options.delete(:scope)  || Object.new
+    locals = options.delete(:locals) || {}
+    Haml::Engine.new(text, options).to_html(scope, locals, &block)
   end
 
   def test_empty_render_should_remain_empty
     assert_equal('', render(''))
   end
 
-  # This is ugly because Hashes are unordered; we don't always know the order
-  # in which attributes will be returned.
-  # There is probably a better way to do this.
   def test_attributes_should_render_correctly
     assert_equal("<div class='atlantis' style='ugly'>\n</div>", render(".atlantis{:style => 'ugly'}").chomp)
-  rescue
-    assert_equal("<div style='ugly' class='atlantis'>\n</div>", render(".atlantis{:style => 'ugly'}").chomp)
   end
 
   def test_ruby_code_should_work_inside_attributes
@@ -50,6 +47,18 @@ class EngineTest < Test::Unit::TestCase
   def test_long_liner_should_not_print_on_one_line
     assert_equal("<div>\n  #{'x' * 51}\n</div>", render("%div #{'x' * 51}").chomp)
   end
+  
+  def test_non_prerendered_one_liner
+    assert_equal("<p class='awesome'>One line</p>\n", render("%p{:class => c} One line", :locals => {:c => 'awesome'}))
+  end
+  
+  def test_non_prerendered_script_one_liner
+    assert_equal("<p class='awesome'>One line</p>\n", render("%p{:class => c}= 'One line'", :locals => {:c => 'awesome'}))
+  end
+  
+  def test_non_prerendered_long_script_one_liner
+    assert_equal("<p class='awesome'>\n  #{'x' * 60}\n</p>\n", render("%p{:class => c}= 'x' * 60", :locals => {:c => 'awesome'}))
+  end
 
   def test_multi_render
     engine = Haml::Engine.new("%strong Hi there!")
@@ -63,6 +72,11 @@ class EngineTest < Test::Unit::TestCase
     assert_equal("<p>\n  Hello World\n</p>\n", render("%p\n  == Hello \#{who}", :locals => {:who => 'World'}))
   end
 
+  def test_double_equals_in_the_middle_of_a_string
+    assert_equal("\"title 'Title'. \"\n",
+                 render("== \"title '\#{\"Title\"}'. \""))
+  end
+
   def test_nil_tag_value_should_render_as_empty
     assert_equal("<p></p>\n", render("%p= nil"))
   end
@@ -71,6 +85,14 @@ class EngineTest < Test::Unit::TestCase
     assert_equal("<p></p>\n", render("%p= 'Hello' if false"))
   end
 
+  def test_static_attributes_with_empty_attr
+    assert_equal("<img alt='' src='/foo.png' />\n", render("%img{:src => '/foo.png', :alt => ''}"))
+  end
+
+  def test_dynamic_attributes_with_empty_attr
+    assert_equal("<img alt='' src='/foo.png' />\n", render("%img{:width => nil, :src => '/foo.png', :alt => String.new}"))
+  end
+
   # Options tests
 
   def test_stop_eval
@@ -84,7 +106,7 @@ class EngineTest < Test::Unit::TestCase
       assert_equal("", render(":ruby\n  puts 'hello'", :suppress_eval => true))
     rescue Haml::HamlError => err
       caught = true
-      assert_equal('Filter "ruby" is not defined!', err.message)
+      assert_equal('"ruby" filter is not defined!', err.message)
     end
     assert(caught, "Rendering a ruby filter without evaluating didn't throw an error!")
   end
@@ -102,25 +124,34 @@ class EngineTest < Test::Unit::TestCase
     assert_equal("<p escaped='quo\nte'>\n</p>\n", render("%p{ :escaped => \"quo\\nte\"}"))
     assert_equal("<p escaped='quo4te'>\n</p>\n", render("%p{ :escaped => \"quo\#{2 + 2}te\"}"))
   end
+  
+  def test_empty_attrs
+    assert_equal("<p attr=''>empty</p>\n", render("%p{ :attr => '' } empty"))
+    assert_equal("<p attr=''>empty</p>\n", render("%p{ :attr => x } empty", :locals => {:x => ''}))
+  end
+  
+  def test_nil_attrs
+    assert_equal("<p>nil</p>\n", render("%p{ :attr => nil } nil"))
+    assert_equal("<p>nil</p>\n", render("%p{ :attr => x } nil", :locals => {:x => nil}))
+  end
 
   def test_locals
     assert_equal("<p>Paragraph!</p>\n", render("%p= text", :locals => { :text => "Paragraph!" }))
   end
-  
-  def test_recompile_with_new_locals
-    template = "%p= (text == 'first time') ? text : new_text"
-    assert_equal("<p>first time</p>\n", render(template, :locals => { :text => "first time" }))
-    assert_equal("<p>second time</p>\n", render(template, :locals => { :text => "recompile", :new_text => "second time" }))
 
-    # Make sure the method called will return junk unless recompiled
-    method_name = Haml::Engine.send(:class_variable_get, '@@method_names')[template]
-    Haml::Engine::CompiledTemplates.module_eval "def #{method_name}(stuff); @haml_stack[-1].push_text 'NOT RECOMPILED', 0; end"
+  def test_deprecated_locals_option
+    Kernel.module_eval do
+      def warn_with_stub(msg); end
+      alias_method :warn_without_stub, :warn
+      alias_method :warn, :warn_with_stub
+    end
+
+    assert_equal("<p>Paragraph!</p>\n", Haml::Engine.new("%p= text", :locals => { :text => "Paragraph!" }).render)
 
-    assert_equal("NOT RECOMPILED\n", render(template, :locals => { :text => "first time" }))
-    assert_equal("<p>first time</p>\n", render(template, :locals => { :text => "first time", :foo => 'bar' }))
+    Kernel.module_eval { alias_method :warn, :warn_without_stub }
   end
 
-  def test_dynamc_attrs_shouldnt_register_as_literal_values
+  def test_dynamic_attrs_shouldnt_register_as_literal_values
     assert_equal("<p a='b2c'>\n</p>\n", render('%p{:a => "b#{1 + 1}c"}'))
     assert_equal("<p a='b2c'>\n</p>\n", render("%p{:a => 'b' + (1 + 1).to_s + 'c'}"))
   end
@@ -134,20 +165,6 @@ class EngineTest < Test::Unit::TestCase
     assert_equal(hash3, hash1)
   end
 
-  def test_exception_type
-    begin
-      render("%p hi\n= undefined")
-    rescue Exception => e
-      assert(e.is_a?(Haml::Error))
-      assert_equal(2, e.haml_line)
-      assert_equal(nil, e.haml_filename)
-      assert_equal('(haml):2', e.backtrace[0])
-    else
-      # Test failed... should have raised an exception
-      assert(false)
-    end
-  end
-
   def test_syntax_errors
     errs = [ "!!!\n  a", "a\n  b", "a\n:foo\nb", "/ a\n  b",
              "% a", "%p a\n  b", "a\n%p=\nb", "%p=\n  a",
@@ -159,81 +176,84 @@ class EngineTest < Test::Unit::TestCase
       begin
         render(err)
       rescue Exception => e
-        assert(e.is_a?(Haml::Error),
-               "#{err.dump} doesn't produce Haml::SyntaxError!")
+        assert(e.is_a?(Haml::Error), "#{err.dump} doesn't produce Haml::SyntaxError")
       else
-        assert(false,
-               "#{err.dump} doesn't produce an exception!")
+        assert(false, "#{err.dump} doesn't produce an exception")
       end
     end
   end
 
+  def test_syntax_error
+    render("a\nb\n!!!\n  c\nd")
+  rescue Haml::SyntaxError => e
+    assert_equal(e.message, "Illegal Nesting: Nesting within a header command is illegal.")
+    assert_equal("(haml):3", e.backtrace[0])
+  rescue Exception => e
+    assert(false, '"a\nb\n!!!\n  c\nd" doesn\'t produce a Haml::SyntaxError')
+  else
+    assert(false, '"a\nb\n!!!\n  c\nd" doesn\'t produce an exception')
+  end
+
+  def test_exception
+    render("%p\n  hi\n  %a= undefined\n= 12")
+  rescue Exception => e
+    assert_match("(haml):3", e.backtrace[0])
+  else
+    # Test failed... should have raised an exception
+    assert(false)
+  end
+
   def test_compile_error
-    begin
-      render("a\nb\n- fee do\nc")
-    rescue Exception => e
-      assert_equal(3, e.haml_line)
-    else
-      assert(false,
-             '"a\nb\n- fee do\nc" doesn\'t produce an exception!')
-    end
+    render("a\nb\n- fee)\nc")
+  rescue Exception => e
+    assert_match(/^compile error\n\(haml\):3: syntax error/i, e.message)
+  else
+    assert(false,
+           '"a\nb\n- fee)\nc" doesn\'t produce an exception!')
   end
 
-  def test_no_bluecloth
-    old_markdown = false
-    if defined?(Haml::Filters::Markdown)
-      old_markdown = Haml::Filters::Markdown
-    end
+  def test_unbalanced_brackets
+    render('== #{1 + 5} foo #{6 + 7 bar #{8 + 9}')
+  rescue Haml::SyntaxError => e
+    assert_equal("Unbalanced brackets.", e.message)
+  end
 
+  def test_no_bluecloth
     Kernel.module_eval do
-      alias_method :haml_old_require, :gem_original_require
-
-      def gem_original_require(file)
+      def gem_original_require_with_bluecloth(file)
         raise LoadError if file == 'bluecloth'
-        haml_old_require(file)
-      end
-    end
-    
-    if old_markdown
-      Haml::Filters.instance_eval do
-        remove_const 'Markdown'
+        gem_original_require_without_bluecloth(file)
       end
+      alias_method :gem_original_require_without_bluecloth, :gem_original_require
+      alias_method :gem_original_require, :gem_original_require_with_bluecloth
     end
 
-    # This is purposefully redundant, so it doesn't stop
-    # haml/filters from being required later on.
-    require 'haml/../haml/filters'
-
-    assert_equal("<h1>Foo</h1>\t<p>- a\n- b</p>\n",
-                 Haml::Engine.new(":markdown\n  Foo\n  ===\n  - a\n  - b").to_html)
-
-    Haml::Filters.instance_eval do
-      remove_const 'Markdown'
+    begin
+      assert_equal("<h1>Foo</h1>\t<p>- a\n- b</p>\n",
+                   Haml::Engine.new(":markdown\n  Foo\n  ===\n  - a\n  - b").to_html)
+    rescue Haml::HamlError => e
+      if e.message == "Can't run Markdown filter; required 'bluecloth' or 'redcloth', but none were found"
+        puts "\nCouldn't require 'bluecloth' or 'redcloth'; skipping a test."
+      else
+        raise e
+      end
     end
 
-    Haml::Filters.const_set('Markdown', old_markdown) if old_markdown
-
     Kernel.module_eval do
-      alias_method :gem_original_require, :haml_old_require
+      alias_method :gem_original_require, :gem_original_require_without_bluecloth
     end
-
-    NOT_LOADED.delete 'bluecloth'
   end
 
   def test_no_redcloth
     Kernel.module_eval do
-      alias_method :haml_old_require2, :gem_original_require
-
-      def gem_original_require(file)
+      def gem_original_require_with_redcloth(file)
         raise LoadError if file == 'redcloth'
-        haml_old_require2(file)
+        gem_original_require_without_redcloth(file)
       end
+      alias_method :gem_original_require_without_redcloth, :gem_original_require
+      alias_method :gem_original_require, :gem_original_require_with_redcloth
     end
 
-    # This is purposefully redundant, so it doesn't stop
-    # haml/filters from being required later on.
-    require 'haml/../haml/../haml/filters'
-
     begin
       Haml::Engine.new(":redcloth\n  _foo_").to_html
     rescue Haml::HamlError
@@ -242,10 +262,30 @@ class EngineTest < Test::Unit::TestCase
     end
 
     Kernel.module_eval do
-      alias_method :gem_original_require2, :haml_old_require
+      alias_method :gem_original_require, :gem_original_require_without_redcloth
+    end
+  end
+
+  def test_no_redcloth_or_bluecloth
+    Kernel.module_eval do
+      def gem_original_require_with_redcloth_and_bluecloth(file)
+        raise LoadError if file == 'redcloth' || file == 'bluecloth'
+        gem_original_require_without_redcloth_and_bluecloth(file)
+      end
+      alias_method :gem_original_require_without_redcloth_and_bluecloth, :gem_original_require
+      alias_method :gem_original_require, :gem_original_require_with_redcloth_and_bluecloth
+    end
+
+    begin
+      Haml::Engine.new(":markdown\n  _foo_").to_html
+    rescue Haml::HamlError
+    else
+      assert(false, "No exception raised!")
     end
 
-    NOT_LOADED.delete 'redcloth'
+    Kernel.module_eval do
+      alias_method :gem_original_require, :gem_original_require_without_redcloth_and_bluecloth
+    end    
   end
 
   def test_local_assigns_dont_modify_class
@@ -258,4 +298,52 @@ class EngineTest < Test::Unit::TestCase
     assert_equal("<p class='struct_user' id='struct_user_new'>New User</p>\n",
                  render("%p[user] New User", :locals => {:user => user}))
   end
+
+  def test_non_literal_attributes
+    assert_equal("<p a1='foo' a2='bar' a3='baz' />\n",
+                 render("%p{a2, a1, :a3 => 'baz'}/",
+                        :locals => {:a1 => {:a1 => 'foo'}, :a2 => {:a2 => 'bar'}}))
+  end
+
+  def test_render_should_accept_a_binding_as_scope
+    string = "This is a string!"
+    string.instance_variable_set("@var", "Instance variable")
+    b = string.instance_eval do
+      var = "Local variable"
+      binding
+    end
+
+    assert_equal("<p>THIS IS A STRING!</p>\n<p>Instance variable</p>\n<p>Local variable</p>\n",
+                 render("%p= upcase\n%p= @var\n%p= var", :scope => b))
+  end
+
+  def test_yield_should_work_with_binding
+    assert_equal("12\nFOO\n", render("= yield\n= upcase", :scope => "foo".instance_eval{binding}) { 12 })
+  end
+
+  def test_yield_should_work_with_def_method
+    s = "foo"
+    Haml::Engine.new("= yield\n= upcase").def_method(s, :render)
+    assert_equal("12\nFOO\n", s.render { 12 })
+  end
+
+  def test_def_method_with_module
+    Haml::Engine.new("= yield\n= upcase").def_method(String, :render_haml)
+    assert_equal("12\nFOO\n", "foo".render_haml { 12 })
+  end
+
+  def test_def_method_locals
+    obj = Object.new
+    Haml::Engine.new("%p= foo\n.bar{:baz => baz}= boom").def_method(obj, :render, :foo, :baz, :boom)
+    assert_equal("<p>1</p>\n<div baz='2' class='bar'>3</div>\n", obj.render(:foo => 1, :baz => 2, :boom => 3))
+  end
+
+  def test_render_proc_locals
+    proc = Haml::Engine.new("%p= foo\n.bar{:baz => baz}= boom").render_proc(Object.new, :foo, :baz, :boom)
+    assert_equal("<p>1</p>\n<div baz='2' class='bar'>3</div>\n", proc[:foo => 1, :baz => 2, :boom => 3])
+  end
+
+  def test_render_proc_with_binding
+    assert_equal("FOO\n", Haml::Engine.new("= upcase").render_proc("foo".instance_eval{binding}).call)
+  end
 end