haml 2.2.24 → 3.0.0.beta.1

data/lib/sass/tree/variable_node.rb

@@ -16,17 +16,21 @@ module Sass
 
       protected
 
+      def to_src(tabs, opts, fmt)
+        "#{'  ' * tabs}$#{@name}: #{@expr.to_sass}#{' !default' if @guarded}#{semi fmt}\n"
+      end
+
       # Loads the new variable value into the environment.
       #
       # @param environment [Sass::Environment] The lexical environment containing
       #   variable and mixin values
       def _perform(environment)
-        if @guarded && environment.var(@name).nil?
-          environment.set_var(@name, @expr.perform(environment))
-        elsif !@guarded
-          environment.set_var(@name, @expr.perform(environment))
+        return [] if @guarded && !environment.var(@name).nil?
+        val = @expr.perform(environment)
+        if @expr.context == :equals && val.is_a?(Sass::Script::String)
+          val = Sass::Script::String.new(val.value)
         end
-
+        environment.set_var(@name, val)
         []
       end
     end

data/lib/sass/tree/while_node.rb

@@ -13,6 +13,10 @@ module Sass::Tree
 
     protected
 
+    def to_src(tabs, opts, fmt)
+      "#{'  ' * tabs}@while #{@expr.to_sass}" + children_to_src(tabs, opts, fmt)
+    end
+
     # Runs the child nodes until the continue expression becomes false.
     #
     # @param environment [Sass::Environment] The lexical environment containing

data/test/benchmark.rb

@@ -40,7 +40,7 @@ RBench.run(times) do
   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")
+  erb_template     = File.read("#{directory}/erb/#{template_name}.erb")
   markaby_template = File.read("#{directory}/markaby/#{template_name}.mab")
 
   report "Cached" do
@@ -64,10 +64,10 @@ RBench.run(times) do
     Haml::Template.options[:ugly] = false
     # To cache the template
     render @base, 'haml/templates/standard'
-    render @base, 'haml/rhtml/standard'
+    render @base, 'haml/erb/standard'
 
     haml { render @base, 'haml/templates/standard' }
-    erb  { render @base, 'haml/rhtml/standard' }
+    erb  { render @base, 'haml/erb/standard' }
 
     Haml::Template.options[:ugly] = true
     render @base, 'haml/templates/standard_ugly'
@@ -81,10 +81,10 @@ RBench.run(times) do
     Haml::Template.options[:ugly] = false
     # To cache the template
     render @base, 'haml/templates/action_view'
-    render @base, 'haml/rhtml/action_view'
+    render @base, 'haml/erb/action_view'
 
     haml { render @base, 'haml/templates/action_view' }
-    erb  { render @base, 'haml/rhtml/action_view' }
+    erb  { render @base, 'haml/erb/action_view' }
 
     Haml::Template.options[:ugly] = true
     render @base, 'haml/templates/action_view_ugly'

data/test/haml/engine_test.rb

@@ -89,6 +89,11 @@ MESSAGE
   }
 
   User = Struct.new('User', :id)
+  class CustomHamlClass < Struct.new(:id)
+    def haml_object_ref
+      "my_thing"
+    end
+  end
 
   def render(text, options = {}, &block)
     scope  = options.delete(:scope)  || Object.new
@@ -137,6 +142,29 @@ MESSAGE
     assert_equal("<p class='3'>foo</p>", render("%p{:class => 1+2} foo").chomp)
   end
 
+  def test_class_attr_with_array
+    assert_equal("<p class='a b'>foo</p>\n", render("%p{:class => %w[a b]} foo")) # basic
+    assert_equal("<p class='a b css'>foo</p>\n", render("%p.css{:class => %w[a b]} foo")) # merge with css
+    assert_equal("<p class='b css'>foo</p>\n", render("%p.css{:class => %w[css b]} foo")) # merge uniquely
+    assert_equal("<p class='a b c d'>foo</p>\n", render("%p{:class => [%w[a b], %w[c d]]} foo")) # flatten
+    assert_equal("<p class='a b'>foo</p>\n", render("%p{:class => [:a, :b] } foo")) # stringify
+    assert_equal("<p class=''>foo</p>\n", render("%p{:class => [nil, false] } foo")) # strip falsey
+    assert_equal("<p class='a'>foo</p>\n", render("%p{:class => :a} foo")) # single stringify
+    assert_equal("<p>foo</p>\n", render("%p{:class => false} foo")) # single falsey
+    assert_equal("<p class='a b html'>foo</p>\n", render("%p(class='html'){:class => %w[a b]} foo")) # html attrs
+  end
+
+  def test_id_attr_with_array
+    assert_equal("<p id='a_b'>foo</p>\n", render("%p{:id => %w[a b]} foo")) # basic
+    assert_equal("<p id='css_a_b'>foo</p>\n", render("%p#css{:id => %w[a b]} foo")) # merge with css
+    assert_equal("<p id='a_b_c_d'>foo</p>\n", render("%p{:id => [%w[a b], %w[c d]]} foo")) # flatten
+    assert_equal("<p id='a_b'>foo</p>\n", render("%p{:id => [:a, :b] } foo")) # stringify
+    assert_equal("<p id=''>foo</p>\n", render("%p{:id => [nil, false] } foo")) # strip falsey
+    assert_equal("<p id='a'>foo</p>\n", render("%p{:id => :a} foo")) # single stringify
+    assert_equal("<p>foo</p>\n", render("%p{:id => false} foo")) # single falsey
+    assert_equal("<p id='html_a_b'>foo</p>\n", render("%p(id='html'){:id => %w[a b]} foo")) # html attrs
+  end
+
   def test_dynamic_attributes_with_no_content
     assert_equal(<<HTML, render(<<HAML))
 <p>
@@ -148,6 +176,20 @@ HTML
 HAML
   end
 
+  def test_attributes_with_to_s
+    assert_equal(<<HTML, render(<<HAML))
+<p id='foo_2'></p>
+<p class='2 foo'></p>
+<p blaz='2'></p>
+<p 2='2'></p>
+HTML
+%p#foo{:id => 1+1}
+%p.foo{:class => 1+1}
+%p{:blaz => 1+1}
+%p{(1+1) => 1+1}
+HAML
+  end
+
   def test_nil_should_render_empty_tag
     assert_equal("<div class='no_attributes'></div>",
                  render(".no_attributes{:nil => nil}").chomp)
@@ -629,15 +671,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
-
   # HTML escaping tests
 
   def test_ampersand_equals_should_escape
@@ -817,13 +850,26 @@ HAML
     assert_equal("<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n", render("!!! XML", :attr_wrapper => '"'))
   end
 
+  def test_autoclose_option
+    assert_equal("<flaz foo='bar' />\n", render("%flaz{:foo => 'bar'}", :autoclose => ["flaz"]))
+    assert_equal(<<HTML, render(<<HAML, :autoclose => [/^flaz/]))
+<flaz />
+<flaznicate />
+<flan></flan>
+HTML
+%flaz
+%flaznicate
+%flan
+HAML
+  end
+
   def test_attrs_parsed_correctly
     assert_equal("<p boom=>biddly='bar =&gt; baz'></p>\n", render("%p{'boom=>biddly' => 'bar => baz'}"))
     assert_equal("<p foo,bar='baz, qux'></p>\n", render("%p{'foo,bar' => 'baz, qux'}"))
     assert_equal("<p escaped='quo&#x000A;te'></p>\n", render("%p{ :escaped => \"quo\\nte\"}"))
     assert_equal("<p escaped='quo4te'></p>\n", render("%p{ :escaped => \"quo\#{2 + 2}te\"}"))
   end
-  
+
   def test_correct_parsing_with_brackets
     assert_equal("<p class='foo'>{tada} foo</p>\n", render("%p{:class => 'foo'} {tada} foo"))
     assert_equal("<p class='foo'>deep {nested { things }}</p>\n", render("%p{:class => 'foo'} deep {nested { things }}"))
@@ -962,6 +1008,21 @@ END
 END
   end
 
+  def test_css_filter
+    assert_equal(<<CSS, render(<<SASS))
+<style type='text/css'>
+  /*<![CDATA[*/
+    #foo {
+      bar: baz; }
+  /*]]>*/
+</style>
+CSS
+:css
+  #foo {
+    bar: baz; }
+SASS
+  end
+
   def test_local_assigns_dont_modify_class
     assert_equal("bar\n", render("= foo", :locals => {:foo => 'bar'}))
     assert_equal(nil, defined?(foo))
@@ -979,6 +1040,12 @@ END
                  render("%p[user]{:style => 'width: 100px;'} New User", :locals => {:user => user}))
   end
 
+  def test_object_ref_with_custom_haml_class
+    custom = CustomHamlClass.new 42
+    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_non_literal_attributes
     assert_equal("<p a1='foo' a2='bar' a3='baz' />\n",
                  render("%p{a2, a1, :a3 => 'baz'}/",
@@ -1133,6 +1200,47 @@ END
     assert_equal %{<!DOCTYPE html>\n}, render('!!!', :format => :html5)
   end
 
+  # HTML5 custom data attributes
+  def test_html5_data_attributes
+    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'}}"))
+
+    assert_equal("<div data-one_plus_one='2'></div>\n",
+      render("%div{:data => {:one_plus_one => 1+1}}"))
+
+    assert_equal("<div data-foo='Here&apos;s a \"quoteful\" string.'></div>\n",
+      render(%{%div{:data => {:foo => %{Here's a "quoteful" string.}}}})) #'
+  end
+
+  def test_html5_data_attributes_with_multiple_defs
+    # Should always use the more-explicit attribute
+    assert_equal("<div data-foo='second'></div>\n",
+      render("%div{:data => {:foo => 'first'}, 'data-foo' => 'second'}"))
+    assert_equal("<div data-foo='first'></div>\n",
+      render("%div{'data-foo' => 'first', :data => {:foo => 'second'}}"))
+  end
+
+  def test_html5_data_attributes_with_attr_method
+    Haml::Helpers.module_eval do
+      def data_hash
+        {:data => {:foo => "bar", :baz => "bang"}}
+      end
+
+      def data_val
+        {:data => "dat"}
+      end
+    end
+
+    assert_equal("<div data-baz='bang' data-brat='wurst' data-foo='blip'></div>\n",
+      render("%div{data_hash, :data => {:foo => 'blip', :brat => 'wurst'}}"))
+    assert_equal("<div data-baz='bang' data-foo='blip'></div>\n",
+      render("%div{data_hash, 'data-foo' => 'blip'}"))
+    assert_equal("<div data-baz='bang' data-foo='bar' data='dat'></div>\n",
+      render("%div{data_hash, :data => 'dat'}"))
+    assert_equal("<div data-brat='wurst' data-foo='blip' data='dat'></div>\n",
+      render("%div{data_val, :data => {:foo => 'blip', :brat => 'wurst'}}"))
+  end
+
   # New attributes
 
   def test_basic_new_attributes
@@ -1233,6 +1341,17 @@ END
 
   # Encodings
 
+  def test_utf_8_bom
+    assert_equal <<CSS, render(<<SCSS)
+<div class='foo'>
+  <p>baz</p>
+</div>
+CSS
+\xEF\xBB\xBF.foo
+  %p baz
+SCSS
+  end
+
   unless Haml::Util.ruby1_8?
     def test_default_encoding
       assert_equal(Encoding.find("utf-8"), render(<<HAML.encode("us-ascii")).encoding)
@@ -1277,6 +1396,24 @@ HAML
         o.render
       end
     end
+
+    def test_encoding_error
+      render("foo\nbar\nb\xFEaz".force_encoding("utf-8"))
+      assert(false, "Expected exception")
+    rescue Haml::Error => e
+      assert_equal(3, e.line)
+      assert_equal('Invalid UTF-8 character "\xFE"', e.message)
+    end
+
+    def test_ascii_incompatible_encoding_error
+      template = "foo\nbar\nb_z".encode("utf-16le")
+      template[9] = "\xFE".force_encoding("utf-16le")
+      render(template)
+      assert(false, "Expected exception")
+    rescue Haml::Error => e
+      assert_equal(3, e.line)
+      assert_equal('Invalid UTF-16LE character "\xFE"', e.message)
+    end
   end
 
   private

data/test/haml/{rhtml/_av_partial_1.rhtml → erb/_av_partial_1.erb}

@@ -6,7 +6,7 @@
       <li>
         <strong>Partial:</strong>
         <% @nesting = 5 %>
-        <%= render :partial => 'haml/rhtml/av_partial_2' %>
+        <%= render :partial => 'haml/erb/av_partial_2' %>
     <% end %>
   </ul>
 </div>

data/test/haml/{rhtml/_av_partial_2.rhtml → erb/_av_partial_2.erb}

@@ -3,6 +3,6 @@
   <h3>This is a crazy deep-nested partial.</h3>
   <p>Nesting level <%= @nesting %></p>
   <% if @nesting > 0 %>
-    <%= render :partial => 'haml/rhtml/av_partial_2' %>
+    <%= render :partial => 'haml/erb/av_partial_2' %>
   <% end %>
 </div>

data/test/haml/{rhtml/action_view.rhtml → erb/action_view.erb}

@@ -11,7 +11,7 @@
       It's only used for benchmarking.
     </h1>
     <div class="crazy_partials">
-      <%= render :partial => 'haml/rhtml/av_partial_1' %>
+      <%= render :partial => 'haml/erb/av_partial_1' %>
     </div>
     <!-- You're In my house now! -->
     <div class='header'>

data/test/haml/helper_test.rb

@@ -15,18 +15,7 @@ module Haml::Helpers
 end
 
 class HelperTest < Test::Unit::TestCase
-  Post = Struct.new('Post', :body, :error_field, :errors)
-  class PostErrors
-    def on(name)
-      return unless name == 'error_field'
-      ["Really bad error"]
-    end
-    alias_method :full_messages, :on
-
-    def [](name)
-      on(name) || []
-    end
-  end
+  Post = Struct.new('Post', :body)
   
   def setup
     @base = ActionView::Base.new
@@ -37,7 +26,7 @@ class HelperTest < Test::Unit::TestCase
       @base.controller.response = ActionController::Response.new
     end
 
-    @base.instance_variable_set('@post', Post.new("Foo bar\nbaz", nil, PostErrors.new))
+    @base.instance_variable_set('@post', Post.new("Foo bar\nbaz"))
   end
 
   def render(text, options = {})
@@ -164,16 +153,48 @@ HTML
 HAML
   end
 
-  def test_content_tag_error_wrapping
-    def @base.protect_against_forgery?; false; end
-    assert_equal(<<HTML, render(<<HAML, :action_view))
-<form action="" method="post">
-  <div class="fieldWithErrors"><label for="post_error_field">Error field</label></div>
-</form>
-HTML
-#{rails_block_helper_char} form_for #{form_for_calling_convention('post')}, :url => '' do |f|
-  = f.label 'error_field'
-HAML
+  def test_haml_tag_name_attribute_with_id
+    assert_equal("<p id='some_id'></p>\n", render("- haml_tag 'p#some_id'"))
+  end
+
+  def test_haml_tag_without_name_but_with_id
+    assert_equal("<div id='some_id'></div>\n", render("- haml_tag '#some_id'"))
+  end
+
+  def test_haml_tag_without_name_but_with_class
+    assert_equal("<div class='foo'></div>\n", render("- haml_tag '.foo'"))
+  end
+
+  def test_haml_tag_name_with_id_and_class
+    assert_equal("<p class='foo' id='some_id'></p>\n", render("- haml_tag 'p#some_id.foo'"))
+  end
+
+  def test_haml_tag_name_with_class
+    assert_equal("<p class='foo'></p>\n", render("- haml_tag 'p.foo'"))
+  end
+
+  def test_haml_tag_name_with_class_and_id
+    assert_equal("<p class='foo' id='some_id'></p>\n", render("- haml_tag 'p.foo#some_id'"))
+  end
+
+  def test_haml_tag_name_with_id_and_multiple_classes
+    assert_equal("<p class='foo bar' id='some_id'></p>\n", render("- haml_tag 'p#some_id.foo.bar'"))
+  end
+
+  def test_haml_tag_name_with_multiple_classes_and_id
+    assert_equal("<p class='foo bar' id='some_id'></p>\n", render("- haml_tag 'p.foo.bar#some_id'"))
+  end
+
+  def test_haml_tag_name_and_attribute_classes_merging
+    assert_equal("<p class='foo bar' id='some_id'></p>\n", render("- haml_tag 'p#some_id.foo', :class => 'bar'"))
+  end
+
+  def test_haml_tag_name_and_attribute_classes_merging
+    assert_equal("<p class='bar foo'></p>\n", render("- haml_tag 'p.foo', :class => 'bar'"))
+  end
+
+  def test_haml_tag_name_merges_id_and_attribute_id
+    assert_equal("<p id='foo_bar'></p>\n", render("- haml_tag 'p#foo', :id => 'bar'"))
   end
 
   def test_haml_tag_attribute_html_escaping
@@ -184,6 +205,16 @@ HAML
     assert_equal("<br class='foo' />\n", render("- haml_tag :br, :class => 'foo'"))
   end
 
+  def test_haml_tag_with_class_array
+    assert_equal("<p class='a b'>foo</p>\n", render("- haml_tag :p, 'foo', :class => %w[a b]"))
+    assert_equal("<p class='a b c d'>foo</p>\n", render("- haml_tag 'p.c.d', 'foo', :class => %w[a b]"))
+  end
+
+  def test_haml_tag_with_id_array
+    assert_equal("<p id='a_b'>foo</p>\n", render("- haml_tag :p, 'foo', :id => %w[a b]"))
+    assert_equal("<p id='c_a_b'>foo</p>\n", render("- haml_tag 'p#c', 'foo', :id => %w[a b]"))
+  end
+
   def test_haml_tag_non_autoclosed_tags_arent_closed
     assert_equal("<p></p>\n", render("- haml_tag :p"))
   end
@@ -208,6 +239,42 @@ HAML
     assert_raise(Haml::Error) { render("= haml_tag :p") }
   end
 
+  def test_haml_tag_with_multiline_string
+    assert_equal(<<HTML, render(<<HAML))
+<p>
+  foo
+  bar
+  baz
+</p>
+HTML
+- haml_tag :p, "foo\\nbar\\nbaz"
+HAML
+  end
+
+  def test_haml_concat_with_multiline_string
+    assert_equal(<<HTML, render(<<HAML))
+<p>
+  foo
+  bar
+  baz
+</p>
+HTML
+%p
+  - haml_concat "foo\\nbar\\nbaz"
+HAML
+  end
+
+  def test_haml_tag_with_ugly
+    assert_equal(<<HTML, render(<<HAML, :ugly => true))
+<p>
+<strong>Hi!</strong>
+</p>
+HTML
+- haml_tag :p do
+  - haml_tag :strong, "Hi!"
+HAML
+  end
+
   def test_is_haml
     assert(!ActionView::Base.new.is_haml?)
     assert_equal("true\n", render("= is_haml?"))
@@ -291,7 +358,7 @@ MESSAGE
     render("%p foo\n= haml_concat 'foo'\n%p bar")
     assert false, "Expected Haml::Error"
   rescue Haml::Error => e
-    assert_equal 2, e.backtrace[0].scan(/:(\d+)/).first.first.to_i
+    assert_equal 2, e.backtrace[1].scan(/:(\d+)/).first.first.to_i
   end
 
   def test_error_return_line_in_helper