haml 3.0.25 → 3.1.0.alpha.2

data/lib/haml/version.rb

@@ -99,4 +99,11 @@ module Haml
       return nil
     end
   end
+
+  extend Haml::Version
+
+  # A string representing the version of Haml.
+  # A more fine-grained representation is available from Haml.version.
+  # @api public
+  VERSION = version[:string] unless defined?(Haml::VERSION)
 end

data/test/benchmark.rb

@@ -5,15 +5,14 @@ times = (ARGV.first || 1000).to_i
 if times == 0 # Invalid parameter
   puts <<END
 ruby #$0 [times=1000]
-  Benchmark Haml against various other templating languages and Sass
-  on its own.
+  Benchmark Haml against various other templating languages.
 END
   exit 1
 end
 
 require File.dirname(__FILE__) + '/../lib/haml'
 require File.dirname(__FILE__) + '/linked_rails'
-%w[sass rubygems erb erubis markaby active_support action_controller
+%w[rubygems erb erubis markaby active_support action_controller
    action_view action_pack haml/template rbench].each {|dep| require(dep)}
 
 def view
@@ -91,9 +90,3 @@ RBench.run(times) do
     haml_ugly { render @base, 'haml/templates/action_view_ugly' }
   end
 end
-
-RBench.run(times) do
-  sass_template = File.read("#{File.dirname(__FILE__)}/sass/templates/complex.sass")
-
-  report("Sass") { Sass::Engine.new(sass_template).render }
-end

data/test/haml/engine_test.rb

@@ -86,7 +86,6 @@ MESSAGE
     "foo\n:plain\n  1\n  2\n  3\#{''}\n4\n- raise 'foo'" => ["foo", 7],
     "foo\n:plain\n  1\n  2\n  \#{raise 'foo'}" => ["foo", 5],
     "= raise 'foo'\nfoo\nbar\nbaz\nbang" => ["foo", 1],
-    "- case 1\n\n- when 1\n  - raise 'foo'" => ["foo", 4],
   }
 
   User = Struct.new('User', :id)
@@ -112,17 +111,6 @@ MESSAGE
     Haml::Engine.new(text, options)
   end
 
-  def setup
-    return if Haml::Util.ruby1_8?
-    @old_default_internal = Encoding.default_internal
-    Encoding.default_internal = nil
-  end
-
-  def teardown
-    return if Haml::Util.ruby1_8?
-    Encoding.default_internal = @old_default_internal
-  end
-
   def test_empty_render
     assert_equal "", render("")
   end
@@ -775,38 +763,6 @@ HTML
 HAML
   end
 
-  def test_case_with_newline_after_case
-    assert_equal(<<HTML, render(<<HAML))
-foo
-HTML
-- case 1
-
-  - when 1
-    foo
-  - when 2
-    bar
-HAML
-
-    assert_equal(<<HTML, render(<<HAML))
-bar
-HTML
-- case 2
-
-- when 1
-  foo
-- when 2
-  bar
-HAML
-  end
-
-  def test_escape_html_with_interpolated_if_statement
-    assert_equal(<<HTML, render(<<HAML, :escape_html => true))
-foo,
-HTML
-foo\#{"," if true}
-HAML
-  end
-
   # HTML escaping tests
 
   def test_ampersand_equals_should_escape
@@ -1145,18 +1101,18 @@ END
   end
 
   def test_css_filter
-    assert_equal(<<CSS, render(<<SASS))
+    assert_equal(<<HTML, render(<<HAML))
 <style type='text/css'>
   /*<![CDATA[*/
     #foo {
       bar: baz; }
   /*]]>*/
 </style>
-CSS
+HTML
 :css
   #foo {
     bar: baz; }
-SASS
+HAML
   end
 
   def test_local_assigns_dont_modify_class
@@ -1389,7 +1345,7 @@ SASS
 
   def test_new_attribute_ids
     assert_equal("<div id='foo_bar'></div>\n", render("#foo(id='bar')"))
-    assert_equal("<div id='foo_baz_bar'></div>\n", render("#foo{:id => 'bar'}(id='baz')"))
+    assert_equal("<div id='foo_bar_baz'></div>\n", render("#foo{:id => 'bar'}(id='baz')"))
     assert_equal("<div id='foo_baz_bar'></div>\n", render("#foo(id='baz'){:id => 'bar'}"))
     foo = User.new(42)
     assert_equal("<div class='struct_user' id='foo_baz_bar_struct_user_42'></div>\n",
@@ -1398,7 +1354,7 @@ SASS
       render("#foo(id='baz')[foo]{:id => 'bar'}", :locals => {:foo => foo}))
     assert_equal("<div class='struct_user' id='foo_baz_bar_struct_user_42'></div>\n",
       render("#foo[foo](id='baz'){:id => 'bar'}", :locals => {:foo => foo}))
-    assert_equal("<div class='struct_user' id='foo_baz_bar_struct_user_42'></div>\n",
+    assert_equal("<div class='struct_user' id='foo_bar_baz_struct_user_42'></div>\n",
       render("#foo[foo]{:id => 'bar'}(id='baz')", :locals => {:foo => foo}))
   end
 
@@ -1470,17 +1426,11 @@ SASS
     assert_equal("<a a='b' c='d'>bar</a>\n", render("%a(c='d'){:a => 'b'} bar"))
     assert_equal("<a a='b' c='d'>bar</a>\n", render("%a{:a => 'b'}(c='d') bar"))
 
-    # Old-style always takes precedence over new-style,
-    # because theoretically old-style could have arbitrary end-of-method-call syntax.
-    assert_equal("<a a='b'>bar</a>\n", render("%a{:a => 'b'}(a='d') bar"))
+    assert_equal("<a a='d'>bar</a>\n", render("%a{:a => 'b'}(a='d') bar"))
     assert_equal("<a a='b'>bar</a>\n", render("%a(a='d'){:a => 'b'} bar"))
 
     assert_equal("<a a='b' b='c' c='d' d='e'>bar</a>\n",
       render("%a{:a => 'b',\n:b => 'c'}(c='d'\nd='e') bar"))
-
-    locals = {:b => 'b', :d => 'd'}
-    assert_equal("<p a='b' c='d'></p>\n", render("%p{:a => b}(c=d)", :locals => locals))
-    assert_equal("<p a='b' c='d'></p>\n", render("%p(a=b){:c => d}", :locals => locals))
   end
 
   # Ruby Multiline
@@ -1556,7 +1506,7 @@ HAML
 
   def test_loud_ruby_multiline_with_block
     assert_equal(<<HTML, render(<<HAML))
-#{%w[far faz fang]}
+farfazfang
 <p>foo</p>
 <p>bar</p>
 HTML
@@ -1686,8 +1636,18 @@ HAML
 HAML
     end
 
+    def test_convert_template_render
+      assert_equal(<<HTML, render(<<HAML.encode("iso-8859-1"), :encoding => "utf-8"))
+<p>bâr</p>
+<p>föö</p>
+HTML
+%p bâr
+%p föö
+HAML
+    end
+
     def test_fake_ascii_encoding
-      assert_encoded_equal(<<HTML.force_encoding("ascii-8bit"), render(<<HAML, :encoding => "ascii-8bit"))
+      assert_equal(<<HTML.force_encoding("ascii-8bit"), render(<<HAML, :encoding => "ascii-8bit"))
 <p>bâr</p>
 <p>föö</p>
 HTML
@@ -1741,23 +1701,15 @@ HTML
 HAML
     end
 
-    def test_coding_comments
-      assert_valid_encoding_comment("-# coding: ibm866")
-      assert_valid_encoding_comment("-# CodINg: IbM866")
-      assert_valid_encoding_comment("-#coding:ibm866")
-      assert_valid_encoding_comment("-# CodINg= ibm866")
-      assert_valid_encoding_comment("-# foo BAR FAOJcoding: ibm866")
-      assert_valid_encoding_comment("-# coding: ibm866 ASFJ (&(&#!$")
-      assert_valid_encoding_comment("-# -*- coding: ibm866")
-      assert_valid_encoding_comment("-# coding: ibm866 -*- coding: blah")
-      assert_valid_encoding_comment("-# -*- coding: ibm866 -*-")
-      assert_valid_encoding_comment("-# -*- encoding: ibm866 -*-")
-      assert_valid_encoding_comment('-# -*- coding: "ibm866" -*-')
-      assert_valid_encoding_comment("-#-*-coding:ibm866-*-")
-      assert_valid_encoding_comment("-#-*-coding:ibm866-*-")
-      assert_valid_encoding_comment("-# -*- foo: bar; coding: ibm866; baz: bang -*-")
-      assert_valid_encoding_comment("-# foo bar coding: baz -*- coding: ibm866 -*-")
-      assert_valid_encoding_comment("-# -*- coding: ibm866 -*- foo bar coding: baz")
+    def test_different_coding_comment_than_encoding
+      assert_renders_encoded(<<HTML.force_encoding("IBM866"), <<HAML)
+<p>bâr</p>
+<p>föö</p>
+HTML
+-# coding: ibm866
+%p bâr
+%p föö
+HAML
     end
 
     def test_different_coding_than_system
@@ -1767,27 +1719,182 @@ HTML
 %p тАЬ
 HAML
     end
-  end
 
-  private
+    def test_case_insensitive_coding_comment
+      assert_renders_encoded(<<HTML.force_encoding("IBM866"), <<HAML)
+<p>bâr</p>
+<p>föö</p>
+HTML
+-# CodINg: IbM866
+%p bâr
+%p föö
+HAML
+    end
 
-  def assert_valid_encoding_comment(comment)
-    assert_renders_encoded(<<HTML.encode("IBM866"), <<HAML.encode("IBM866").force_encoding("UTF-8"))
-<p>ЖЛЫ</p>
-<p>тАЬ</p>
+    def test_whitespace_insensitive_coding_comment
+      assert_renders_encoded(<<HTML.force_encoding("IBM866"), <<HAML)
+<p>bâr</p>
+<p>föö</p>
 HTML
-#{comment}
-%p ЖЛЫ
-%p тАЬ
+-#coding:ibm866
+%p bâr
+%p föö
+HAML
+    end
+
+    def test_equals_coding_comment
+      assert_renders_encoded(<<HTML.force_encoding("IBM866"), <<HAML)
+<p>bâr</p>
+<p>föö</p>
+HTML
+-# CodINg= ibm866
+%p bâr
+%p föö
+HAML
+    end
+
+    def test_prefixed_coding_comment
+      assert_renders_encoded(<<HTML.force_encoding("IBM866"), <<HAML)
+<p>bâr</p>
+<p>föö</p>
+HTML
+-# foo BAR FAOJcoding: ibm866
+%p bâr
+%p föö
+HAML
+    end
+
+    def test_suffixed_coding_comment
+      assert_renders_encoded(<<HTML.force_encoding("IBM866"), <<HAML)
+<p>bâr</p>
+<p>föö</p>
+HTML
+-# coding: ibm866 ASFJ (&(&#!$
+%p bâr
+%p föö
 HAML
+    end
+
+    def test_emacs_prefixed_coding_comment
+      assert_renders_encoded(<<HTML.force_encoding("IBM866"), <<HAML)
+<p>bâr</p>
+<p>föö</p>
+HTML
+-# -*- coding: ibm866
+%p bâr
+%p föö
+HAML
+    end
+
+    def test_emacs_suffixed_coding_comment
+      assert_renders_encoded(<<HTML.force_encoding("IBM866"), <<HAML)
+<p>bâr</p>
+<p>föö</p>
+HTML
+-# coding: ibm866 -*- coding: blah
+%p bâr
+%p föö
+HAML
+    end
+
+    def test_emacs_coding_comment
+      assert_renders_encoded(<<HTML.force_encoding("IBM866"), <<HAML)
+<p>bâr</p>
+<p>föö</p>
+HTML
+-# -*- coding: ibm866 -*-
+%p bâr
+%p föö
+HAML
+    end
+
+    def test_emacs_encoding_comment
+      assert_renders_encoded(<<HTML.force_encoding("IBM866"), <<HAML)
+<p>bâr</p>
+<p>föö</p>
+HTML
+-# -*- encoding: ibm866 -*-
+%p bâr
+%p föö
+HAML
+    end
+
+    def test_quoted_emacs_coding_comment
+      assert_renders_encoded(<<HTML.force_encoding("IBM866"), <<HAML)
+<p>bâr</p>
+<p>föö</p>
+HTML
+-# -*- coding: "ibm866" -*-
+%p bâr
+%p föö
+HAML
+    end
+
+    def test_whitespace_insensitive_emacs_coding_comment
+      assert_renders_encoded(<<HTML.force_encoding("IBM866"), <<HAML)
+<p>bâr</p>
+<p>föö</p>
+HTML
+-#-*-coding:ibm866-*-
+%p bâr
+%p föö
+HAML
+    end
+
+    def test_whitespace_insensitive_emacs_coding_comment
+      assert_renders_encoded(<<HTML.force_encoding("IBM866"), <<HAML)
+<p>bâr</p>
+<p>föö</p>
+HTML
+-#-*-coding:ibm866-*-
+%p bâr
+%p föö
+HAML
+    end
+
+    def test_one_of_several_emacs_comments
+      assert_renders_encoded(<<HTML.force_encoding("IBM866"), <<HAML)
+<p>bâr</p>
+<p>föö</p>
+HTML
+-# -*- foo: bar; coding: ibm866; baz: bang -*-
+%p bâr
+%p föö
+HAML
+    end
+
+    def test_prefixed_emacs_coding_comment
+      assert_renders_encoded(<<HTML.force_encoding("IBM866"), <<HAML)
+<p>bâr</p>
+<p>föö</p>
+HTML
+-# foo bar coding: baz -*- coding: ibm866 -*-
+%p bâr
+%p föö
+HAML
+    end
+
+    def test_suffixed_emacs_coding_comment
+      assert_renders_encoded(<<HTML.force_encoding("IBM866"), <<HAML)
+<p>bâr</p>
+<p>föö</p>
+HTML
+-# -*- coding: ibm866 -*- foo bar coding: baz
+%p bâr
+%p föö
+HAML
+    end
+
   end
 
+  private
+
   def assert_converts_template_properly
-    engine = Haml::Engine.new(<<HAML.encode("iso-8859-1"), :encoding => "macRoman")
+    engine = Haml::Engine.new(<<HAML.encode("iso-8859-1"), :encoding => "utf-8")
 %p bâr
 %p föö
 HAML
-    assert_encoded_equal(<<HTML.encode("macRoman"), yield(engine))
+    assert_equal(<<HTML, yield(engine))
 <p>bâr</p>
 <p>föö</p>
 HTML
@@ -1795,11 +1902,7 @@ HTML
 
   def assert_renders_encoded(html, haml)
     result = render(haml)
-    assert_encoded_equal html, result
-  end
-
-  def assert_encoded_equal(expected, actual)
-    assert_equal expected.encoding, actual.encoding
-    assert_equal expected, actual
+    assert_equal html.encoding, result.encoding
+    assert_equal html, result
   end
 end

data/test/haml/html2haml/erb_tests.rb

@@ -421,20 +421,6 @@ HAML
     <tr></tr>
   <% end %>
 </table>
-ERB
-  end
-
-  def test_silent_inside_block_inside_tag
-    assert_equal(<<HAML.rstrip, render_erb(<<ERB))
-%table
-  - foo.each do
-    - haml_puts "foo"
-HAML
-<table>
-  <% foo.each do %>
-    <% haml_puts "foo" %>
-  <% end %>
-</table>
 ERB
   end
 end

data/test/haml/util_test.rb

@@ -5,6 +5,19 @@ require 'pathname'
 class UtilTest < Test::Unit::TestCase
   include Haml::Util
 
+  class Dumpable
+    attr_reader :arr
+    def initialize; @arr = []; end
+    def _before_dump; @arr << :before; end
+    def _after_dump; @arr << :after; end
+    def _around_dump
+      @arr << :around_before
+      yield
+      @arr << :around_after
+    end
+    def _after_load; @arr << :loaded; end
+  end
+
   def test_scope
     assert(File.exist?(scope("Rakefile")))
   end
@@ -240,6 +253,25 @@ class UtilTest < Test::Unit::TestCase
     assert(!version_gt(v2, v1), "Expected #{v2} = #{v1}")
   end
 
+  def test_dump_and_load
+    obj = Dumpable.new
+    data = dump(obj)
+    assert_equal([:before, :around_before, :around_after, :after], obj.arr)
+    obj2 = load(data)
+    assert_equal([:before, :around_before, :loaded], obj2.arr)
+  end
+
+  class FooBar
+    def foo
+      Haml::Util.abstract(self)
+    end
+  end
+
+  def test_abstract
+    assert_raise_message(NotImplementedError,
+      "UtilTest::FooBar must implement #foo") {FooBar.new.foo}
+  end
+
   def test_def_static_method
     klass = Class.new
     def_static_method(klass, :static_method, [:arg1, :arg2],