haml 3.2.0.alpha.10 → 3.2.0.alpha.13

data/lib/haml/version.rb

@@ -1,109 +1,3 @@
-require 'haml/util'
-
 module Haml
-  # Handles Haml version-reporting.
-  # Haml not only reports the standard three version numbers,
-  # but its Git revision hash as well,
-  # if it was installed from Git.
-  module Version
-    include Haml::Util
-
-    # Returns a hash representing the version of Haml.
-    # The `:major`, `:minor`, and `:teeny` keys have their respective numbers as Fixnums.
-    # The `:name` key has the name of the version.
-    # The `:string` key contains a human-readable string representation of the version.
-    # The `:number` key is the major, minor, and teeny keys separated by periods.
-    # If Haml is checked out from Git, the `:rev` key will have the revision hash.
-    # For example:
-    #
-    #     {
-    #       :string => "2.1.0.9616393",
-    #       :rev    => "9616393b8924ef36639c7e82aa88a51a24d16949",
-    #       :number => "2.1.0",
-    #       :major  => 2, :minor => 1, :teeny => 0
-    #     }
-    #
-    # If a prerelease version of Haml is being used,
-    # the `:string` and `:number` fields will reflect the full version
-    # (e.g. `"2.2.beta.1"`), and the `:teeny` field will be `-1`.
-    # A `:prerelease` key will contain the name of the prerelease (e.g. `"beta"`),
-    # and a `:prerelease_number` key will contain the rerelease number.
-    # For example:
-    #
-    #     {
-    #       :string => "3.0.beta.1",
-    #       :number => "3.0.beta.1",
-    #       :major => 3, :minor => 0, :teeny => -1,
-    #       :prerelease => "beta",
-    #       :prerelease_number => 1
-    #     }
-    #
-    # @return [{Symbol => String/Fixnum}] The version hash
-    def version
-      return @@version if defined?(@@version)
-
-      numbers = File.read(scope('VERSION')).strip.split('.').
-        map {|n| n =~ /^[0-9]+$/ ? n.to_i : n}
-      name = File.read(scope('VERSION_NAME')).strip
-      @@version = {
-        :major => numbers[0],
-        :minor => numbers[1],
-        :teeny => numbers[2],
-        :name => name
-      }
-
-      if numbers[3].is_a?(String)
-        @@version[:teeny] = -1
-        @@version[:prerelease] = numbers[3]
-        @@version[:prerelease_number] = numbers[4]
-      end
-
-      @@version[:number] = numbers.join('.')
-      @@version[:string] = @@version[:number].dup
-
-      if rev = revision_number
-        @@version[:rev] = rev
-        unless rev[0] == ?(
-          @@version[:string] << "." << rev[0...7]
-        end
-      end
-
-      @@version[:string] << " (#{name})"
-      @@version
-    end
-
-    private
-
-    def revision_number
-      if File.exists?(scope('REVISION'))
-        rev = File.read(scope('REVISION')).strip
-        return rev unless rev =~ /^([a-f0-9]+|\(.*\))$/ || rev == '(unknown)'
-      end
-
-      return unless File.exists?(scope('.git/HEAD'))
-      rev = File.read(scope('.git/HEAD')).strip
-      return rev unless rev =~ /^ref: (.*)$/
-
-      ref_name = $1
-      ref_file = scope(".git/#{ref_name}")
-      info_file = scope(".git/info/refs")
-      return File.read(ref_file).strip if File.exists?(ref_file)
-      return unless File.exists?(info_file)
-      File.open(info_file) do |f|
-        f.each do |l|
-          sha, ref = l.strip.split("\t", 2)
-          next unless ref == ref_name
-          return sha
-        end
-      end
-      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)
+  VERSION = "3.2.0.alpha.13"
 end

data/test/{haml/engine_test.rb → engine_test.rb}

@@ -1,8 +1,7 @@
-#!/usr/bin/env ruby
 # -*- coding: utf-8 -*-
-require File.dirname(__FILE__) + '/../test_helper'
+require 'test_helper'
 
-class EngineTest < Test::Unit::TestCase
+class EngineTest < MiniTest::Unit::TestCase
   # A map of erroneous Haml documents to the error messages they should produce.
   # The error messages may be arrays;
   # if so, the second element should be the line number that should be reported for the error.
@@ -61,11 +60,11 @@ MESSAGE
     "%p(foo 'bar')" => "Invalid attribute list: \"(foo 'bar')\".",
     "%p(foo 'bar'\nbaz='bang')" => ["Invalid attribute list: \"(foo 'bar'\".", 1],
     "%p(foo='bar'\nbaz 'bang'\nbip='bop')" => ["Invalid attribute list: \"(foo='bar' baz 'bang'\".", 2],
-    "%p{:foo => 'bar' :bar => 'baz'}" => :compile,
+    "%p{'foo' => 'bar' 'bar' => 'baz'}" => :compile,
     "%p{:foo => }" => :compile,
     "%p{=> 'bar'}" => :compile,
-    "%p{:foo => 'bar}" => :compile,
     "%p{'foo => 'bar'}" => :compile,
+    "%p{:foo => 'bar}" => :compile,
     "%p{:foo => 'bar\"}" => :compile,
 
     # Regression tests
@@ -106,7 +105,7 @@ MESSAGE
     locals = options.delete(:locals) || {}
     engine(text, options).to_html(scope, locals, &block)
   end
-  
+
   def engine(text, options = {})
     unless options[:filename]
       # use caller method name as fake filename. useful for debugging
@@ -118,14 +117,14 @@ MESSAGE
   end
 
   def setup
-    return if Haml::Util.ruby1_8?
+    return if RUBY_VERSION < "1.9"
     @old_default_internal = Encoding.default_internal
-    Encoding.default_internal = nil
+    silence_warnings{Encoding.default_internal = nil}
   end
 
   def teardown
-    return if Haml::Util.ruby1_8?
-    Encoding.default_internal = @old_default_internal
+    return if RUBY_VERSION < "1.9"
+    silence_warnings{Encoding.default_internal = @old_default_internal}
   end
 
   def test_empty_render
@@ -155,7 +154,6 @@ MESSAGE
   end
 
   def test_ruby_code_should_work_inside_attributes
-    author = 'hcatlin'
     assert_equal("<p class='3'>foo</p>", render("%p{:class => 1+2} foo").chomp)
   end
 
@@ -193,11 +191,11 @@ MESSAGE
   def test_dynamic_attributes_with_no_content
     assert_equal(<<HTML, render(<<HAML))
 <p>
-  <a href='http://haml-lang.com'></a>
+  <a href='http://haml.info'></a>
 </p>
 HTML
 %p
-  %a{:href => "http://" + "haml-lang.com"}
+  %a{:href => "http://" + "haml.info"}
 HAML
   end
 
@@ -373,6 +371,16 @@ HAML
                  render("%p{:foo => 'bar', :bar => false, :baz => 'false'}", :format => :xhtml))
   end
 
+  def test_nuke_inner_whitespace_in_loops
+    assert_equal(<<HTML, render(<<HAML))
+<ul>foobarbaz</ul>
+HTML
+%ul<
+  - for str in %w[foo bar baz]
+    = str
+HAML
+  end
+
   def test_both_whitespace_nukes_work_together
     assert_equal(<<RESULT, render(<<SOURCE))
 <p><q>Foo
@@ -403,7 +411,7 @@ HAML
 
   # Regression tests
 
-  unless Haml::Util.ruby1_8?
+  unless RUBY_VERSION < "1.9"
     def test_indentation_after_dynamic_attr_hash
       assert_equal(<<HTML, render(<<HAML))
 <html>
@@ -714,62 +722,12 @@ HAML
     assert_equal("<a href='#'></a>\n", render('%a(href="#")'))
   end
 
-  def test_javascript_filter_with_dynamic_interp_and_escape_html
-    assert_equal(<<HTML, render(<<HAML, :escape_html => true))
-<script type='text/javascript'>
-  //<![CDATA[
-    & < > &
-  //]]>
-</script>
-HTML
-:javascript
- & < > \#{"&"}
-HAML
-  end
-
-  def test_html5_javascript_filter
-    assert_equal(<<HTML, render(<<HAML, :format => :html5))
-<script>
-  //<![CDATA[
-    foo bar
-  //]]>
-</script>
-HTML
-:javascript
-  foo bar
-HAML
-  end
-
-  def test_html5_css_filter
-    assert_equal(<<HTML, render(<<HAML, :format => :html5))
-<style>
-  /*<![CDATA[*/
-    foo bar
-  /*]]>*/
-</style>
-HTML
-:css
-  foo bar
-HAML
-  end
-
-  def test_erb_filter_with_multiline_expr
-    assert_equal(<<HTML, render(<<HAML))
-foobarbaz
-HTML
-:erb
-  <%= "foo" +
-      "bar" +
-      "baz" %>
-HAML
-  end
-
   def test_silent_script_with_hyphen_case
-    assert_equal("", render("- 'foo-case-bar-case'"))
+    assert_equal("", render("- a = 'foo-case-bar-case'"))
   end
 
   def test_silent_script_with_hyphen_end
-    assert_equal("", render("- 'foo-end-bar-end'"))
+    assert_equal("", render("- a = 'foo-end-bar-end'"))
   end
 
   def test_silent_script_with_hyphen_end_and_block
@@ -811,15 +769,6 @@ HAML
     assert_equal("<a href='#\"'></a>\n", render('%a(href="#\\"")'))
   end
 
-  def test_filter_with_newline_and_interp
-    assert_equal(<<HTML, render(<<HAML))
-\\n
-HTML
-:plain
-  \\n\#{""}
-HAML
-  end
-
   def test_case_assigned_to_var
     assert_equal(<<HTML, render(<<HAML))
 bar
@@ -892,9 +841,9 @@ HAML
 foo
 HTML
 - var = if false
-- elsif 12
+- elsif 12 == 12
   - "foo"
-- elsif 14; "bar"
+- elsif 14 == 14; "bar"
 - else
   - "baz"
 = var
@@ -964,7 +913,7 @@ HAML
   def test_bang_equals_inline_should_not_escape
     assert_equal("<p>foo & bar</p>\n", render("%p!= 'foo & bar'", :escape_html => true))
   end
-  
+
   def test_static_attributes_should_be_escaped
     assert_equal("<img class='atlantis' style='ugly&amp;stupid' />\n",
                  render("%img.atlantis{:style => 'ugly&stupid'}"))
@@ -1075,7 +1024,9 @@ HAML
       render("\n\n= 123\n\n= nil[]", :filename => 'test', :line => 2)
     rescue Exception => e
       assert_kind_of NoMethodError, e
-      assert_match(/test:6/, e.backtrace.first)
+      backtrace = e.backtrace
+      backtrace.shift if rubinius?
+      assert_match(/test:6/, backtrace.first)
     end
   end
 
@@ -1118,7 +1069,7 @@ HAML
     assert_equal("<p strange=*attrs*></p>\n", render("%p{ :strange => 'attrs'}", :attr_wrapper => '*'))
     assert_equal("<p escaped='quo\"te'></p>\n", render("%p{ :escaped => 'quo\"te'}", :attr_wrapper => '"'))
     assert_equal("<p escaped=\"quo'te\"></p>\n", render("%p{ :escaped => 'quo\\'te'}", :attr_wrapper => '"'))
-    assert_equal("<p escaped=\"q'uo&quot;te\"></p>\n", render("%p{ :escaped => 'q\\'uo\"te'}", :attr_wrapper => '"'))
+    assert_equal("<p escaped=\"q'uo&#x0022;te\"></p>\n", render("%p{ :escaped => 'q\\'uo\"te'}", :attr_wrapper => '"'))
     assert_equal("<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n", render("!!! XML", :attr_wrapper => '"'))
   end
 
@@ -1147,7 +1098,7 @@ HAML
     assert_equal("<p class='foo'>deep {nested { things }}</p>\n", render("%p{:class => 'foo'} deep {nested { things }}"))
     assert_equal("<p class='bar foo'>{a { d</p>\n", render("%p{{:class => 'foo'}, :class => 'bar'} {a { d"))
     assert_equal("<p foo='bar'>a}</p>\n", render("%p{:foo => 'bar'} a}"))
-    
+
     foo = []
     foo[0] = Struct.new('Foo', :id).new
     assert_equal("<p class='struct_foo' id='struct_foo_new'>New User]</p>\n",
@@ -1161,12 +1112,12 @@ HAML
     assert_equal("<p class='prefix_struct_foo' id='prefix_struct_foo_1'>New User]</p>\n",
                  render("%p[foo[0], :prefix] New User]", :locals => {:foo => foo}))
   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}))
@@ -1201,33 +1152,19 @@ HAML
   EXCEPTION_MAP.each do |key, value|
     define_method("test_exception (#{key.inspect})") do
       begin
-        render(key, :filename => __FILE__)
+        render(key, :filename => "(test_exception (#{key.inspect}))")
       rescue Exception => err
         value = [value] unless value.is_a?(Array)
         expected_message, line_no = value
         line_no ||= key.split("\n").length
 
+
         if expected_message == :compile
-          if Haml::Util.ruby1_8?
-            assert_match(/^compile error\n/, err.message, "Line: #{key}")
-          else
-            assert_match(/^#{Regexp.quote __FILE__}:#{line_no}: syntax error,/, err.message, "Line: #{key}")
-          end
+          assert_match(/(compile error|syntax error|unterminated string|expecting)/, err.message, "Line: #{key}")
         else
           assert_equal(expected_message, err.message, "Line: #{key}")
         end
 
-        if Haml::Util.ruby1_8?
-          # Sometimes, the first backtrace entry is *only* in the message.
-          # No idea why.
-          bt =
-            if expected_message == :compile && err.message.include?("\n")
-              err.message.split("\n", 2)[1]
-            else
-              err.backtrace[0]
-            end
-          assert_match(/^#{Regexp.escape(__FILE__)}:#{line_no}/, bt, "Line: #{key}")
-        end
       else
         assert(false, "Exception not raised for\n#{key}")
       end
@@ -1245,7 +1182,9 @@ HAML
   def test_exception
     render("%p\n  hi\n  %a= undefined\n= 12")
   rescue Exception => e
-    assert_match("(test_exception):3", e.backtrace[0])
+    backtrace = e.backtrace
+    backtrace.shift if rubinius?
+    assert_match("(test_exception):3", backtrace[0])
   else
     # Test failed... should have raised an exception
     assert(false)
@@ -1254,7 +1193,7 @@ HAML
   def test_compile_error
     render("a\nb\n- fee)\nc")
   rescue Exception => e
-    assert_match(/\(test_compile_error\):3: syntax error/i, e.message)
+    assert_match(/\(test_compile_error\):3: (syntax error|expecting \$end)/i, e.message)
   else
     assert(false,
            '"a\nb\n- fee)\nc" doesn\'t produce an exception!')
@@ -1271,38 +1210,6 @@ HAML
                  render("/[if !(IE 6)|(IE 7)] Bracket: ]"))
   end
 
-  def test_empty_filter
-    assert_equal(<<END, render(':javascript'))
-<script type='text/javascript'>
-  //<![CDATA[
-    
-  //]]>
-</script>
-END
-  end
-
-  def test_ugly_filter
-    assert_equal(<<END, render(":sass\n  #foo\n    bar: baz", :ugly => true))
-#foo {
-  bar: baz; }
-END
-  end
-
-  def test_css_filter
-    assert_equal(<<HTML, render(<<HAML))
-<style type='text/css'>
-  /*<![CDATA[*/
-    #foo {
-      bar: baz; }
-  /*]]>*/
-</style>
-HTML
-:css
-  #foo {
-    bar: baz; }
-HAML
-  end
-
   def test_local_assigns_dont_modify_class
     assert_equal("bar\n", render("= foo", :locals => {:foo => 'bar'}))
     assert_equal(nil, defined?(foo))
@@ -1325,7 +1232,7 @@ HAML
     assert_equal("<p class='my_thing' id='my_thing_42' style='width: 100px;'>My Thing</p>\n",
                  render("%p[custom]{:style => 'width: 100px;'} My Thing", :locals => {:custom => custom}))
   end
-  
+
   def test_object_ref_with_multiple_ids
     cpk_record = CpkRecord.new([42,6,9])
     assert_equal("<p class='struct_cpk_record' id='struct_cpk_record_42_6_9' style='width: 100px;'>CPK Record</p>\n",
@@ -1343,6 +1250,9 @@ HAML
     string.instance_variable_set("@var", "Instance variable")
     b = string.instance_eval do
       var = "Local variable"
+      # Silence unavoidable warning; Ruby doesn't know we're going to use this
+      # later.
+      nil if var
       binding
     end
 
@@ -1430,7 +1340,7 @@ HAML
   end
 
   def test_arbitrary_output_option
-    assert_raise_message(Haml::Error, "Invalid output format :html1") do
+    assert_raises_message(Haml::Error, "Invalid output format :html1") do
       engine("%br", :format => :html1)
     end
   end
@@ -1480,7 +1390,7 @@ HAML
 
   # because anything before the doctype triggers quirks mode in IE
   def test_xml_prolog_and_doctype_dont_result_in_a_leading_whitespace_in_html
-    assert_no_match(/^\s+/, render("!!! xml\n!!!", :format => :html4))
+    refute_match(/^\s+/, render("!!! xml\n!!!", :format => :html4))
   end
 
   # HTML5
@@ -1489,15 +1399,41 @@ HAML
   end
 
   # HTML5 custom data attributes
-  def test_html5_data_attributes
+  def test_html5_data_attributes_without_hyphenation
     assert_equal("<div data-author_id='123' data-biz='baz' data-foo='bar'></div>\n",
-      render("%div{:data => {:author_id => 123, :foo => 'bar', :biz => 'baz'}}"))
+      render("%div{:data => {:author_id => 123, :foo => 'bar', :biz => 'baz'}}",
+        :hyphenate_data_attrs => false))
 
     assert_equal("<div data-one_plus_one='2'></div>\n",
-      render("%div{:data => {:one_plus_one => 1+1}}"))
+      render("%div{:data => {:one_plus_one => 1+1}}",
+        :hyphenate_data_attrs => false))
+
+    assert_equal("<div data-foo='Here&#x0027;s a \"quoteful\" string.'></div>\n",
+      render(%{%div{:data => {:foo => %{Here's a "quoteful" string.}}}},
+        :hyphenate_data_attrs => false)) #'
+  end
+
+  def test_html5_data_attributes_with_hyphens
+    assert_equal("<div data-foo-bar='blip'></div>\n",
+      render("%div{:data => {:foo_bar => 'blip'}}"))
+    assert_equal("<div data-baz='bang' data-foo-bar='blip'></div>\n",
+      render("%div{:data => {:foo_bar => 'blip', :baz => 'bang'}}"))
+  end
+
+  def test_html5_data_attributes_with_nested_hash
+    assert_equal("<div data-a-b='c'></div>\n", render(<<-HAML))
+- hash = {:a => {:b => 'c'}}
+- hash[:d] = hash
+%div{:data => hash}
+HAML
+  end
 
-    assert_equal("<div data-foo='Here&apos;s a \"quoteful\" string.'></div>\n",
-      render(%{%div{:data => {:foo => %{Here's a "quoteful" string.}}}})) #'
+  def test_html5_data_attributes_with_nested_hash_and_without_hyphenation
+    assert_equal("<div data-a_b='c'></div>\n", render(<<-HAML, :hyphenate_data_attrs => false))
+- hash = {:a => {:b => 'c'}}
+- hash[:d] = hash
+%div{:data => hash}
+HAML
   end
 
   def test_html5_data_attributes_with_multiple_defs
@@ -1529,6 +1465,36 @@ HAML
       render("%div{data_val, :data => {:foo => 'blip', :brat => 'wurst'}}"))
   end
 
+  def test_xml_doc_using_html5_format_and_mime_type
+    assert_equal(<<XML, render(<<HAML, { :format => :html5, :mime_type => 'text/xml' }))
+<?xml version='1.0' encoding='utf-8' ?>
+<root>
+  <element />
+  <hr />
+</root>
+XML
+!!! XML
+%root
+  %element/
+  %hr
+HAML
+  end
+
+  def test_xml_doc_using_html4_format_and_mime_type
+    assert_equal(<<XML, render(<<HAML, { :format => :html4, :mime_type => 'text/xml' }))
+<?xml version='1.0' encoding='utf-8' ?>
+<root>
+  <element />
+  <hr />
+</root>
+XML
+!!! XML
+%root
+  %element/
+  %hr
+HAML
+  end
+
   # New attributes
 
   def test_basic_new_attributes
@@ -1662,6 +1628,34 @@ HTML
 HAML
   end
 
+  def test_ruby_multiline_with_punctuated_methods_is_continuation
+    assert_equal(<<HTML, render(<<HAML))
+bar, , true, bang
+<p>foo</p>
+<p>bar</p>
+HTML
+= ["bar",
+   "  ".strip!,
+   "".empty?,
+   "bang"].join(", ")
+%p foo
+%p bar
+HAML
+  end
+
+  def test_ruby_character_literals_are_not_continuation
+    html = if RUBY_VERSION < "1.9"
+      "44\n44\n<p>foo</p>\n"
+    else
+      ",\n,\n<p>foo</p>\n"
+    end
+    assert_equal(html, render(<<HAML))
+= ?,
+= ?\,
+%p foo
+HAML
+  end
+
   def test_escaped_loud_ruby_multiline
     assert_equal(<<HTML, render(<<HAML))
 bar&lt;, baz, bang
@@ -1828,7 +1822,7 @@ HTML
 HAML
   end
 
-  unless Haml::Util.ruby1_8?
+  unless RUBY_VERSION < "1.9"
     def test_default_encoding
       assert_equal(Encoding.find("utf-8"), render(<<HAML.encode("us-ascii")).encoding)
 %p bar