radiantcms-couchrest_model 0.1.3 → 0.1.4

data/vendor/plugins/haml/test/haml/helper_test.rb

@@ -1,14 +1,11 @@
 #!/usr/bin/env ruby
 require File.dirname(__FILE__) + '/../test_helper'
+require 'haml/template'
 
 class ActionView::Base
   def nested_tag
     content_tag(:span) {content_tag(:div) {"something"}}
   end
-
-  def wacky_form
-    form_tag("/foo") {"bar"}
-  end
 end
 
 module Haml::Helpers
@@ -122,7 +119,7 @@ HAML
     # This is usually provided by ActionController::Base.
     def @base.protect_against_forgery?; false; end
     assert_equal(<<HTML, render(<<HAML, :action_view))
-<form #{rails_form_attr}action="foo" method="post">#{rails_form_opener}
+<form action="foo" method="post">
   <p>bar</p>
   <strong>baz</strong>
 </form>
@@ -169,10 +166,9 @@ HAML
 
   def test_content_tag_error_wrapping
     def @base.protect_against_forgery?; false; end
-    error_class = Haml::Util.ap_geq_3? ? "field_with_errors" : "fieldWithErrors"
     assert_equal(<<HTML, render(<<HAML, :action_view))
-<form #{rails_form_attr}action="" method="post">#{rails_form_opener}
-  <div class="#{error_class}"><label for="post_error_field">Error field</label></div>
+<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|
@@ -180,67 +176,6 @@ HTML
 HAML
   end
 
-  def test_form_tag_in_helper_with_string_block
-    def @base.protect_against_forgery?; false; end
-    assert_equal(<<HTML, render(<<HAML, :action_view))
-<form #{rails_form_attr}action="/foo" method="post">#{rails_form_opener}bar</form>
-HTML
-#{rails_block_helper_char} wacky_form
-HAML
-  end
-
-  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_name_attribute_with_colon_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_without_name_but_with_colon_class
-    assert_equal("<div class='foo:bar'></div>\n", render("- haml_tag '.foo:bar'"))
-  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
     assert_equal("<p id='foo&amp;bar'>baz</p>\n", render("%p{:id => 'foo&bar'} baz", :escape_html => true))
   end
@@ -249,21 +184,6 @@ 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_with_data_hash
-    assert_equal("<p data-baz='data-baz' data-foo='bar'>foo</p>\n",
-      render("- haml_tag :p, 'foo', :data => {:foo => 'bar', :baz => true}"))
-  end
-
   def test_haml_tag_non_autoclosed_tags_arent_closed
     assert_equal("<p></p>\n", render("- haml_tag :p"))
   end
@@ -288,42 +208,6 @@ 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?"))
@@ -341,8 +225,7 @@ HAML
   end
 
   def test_indented_capture
-    prior = Haml::Util.ap_geq_3? ? "" : "  \n"
-    assert_equal("#{prior}  Foo\n  ", @base.render(:inline => "  <% res = capture do %>\n  Foo\n  <% end %><%= res %>"))
+    assert_equal("  \n  Foo\n  ", @base.render(:inline => "  <% res = capture do %>\n  Foo\n  <% end %><%= res %>"))
   end
 
   def test_capture_deals_properly_with_collections
@@ -408,14 +291,14 @@ 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[1].scan(/:(\d+)/).first.first.to_i
+    assert_equal 2, e.backtrace[0].scan(/:(\d+)/).first.first.to_i
   end
 
   def test_error_return_line_in_helper
     render("- something_that_uses_haml_concat")
     assert false, "Expected Haml::Error"
   rescue Haml::Error => e
-    assert_equal 16, e.backtrace[0].scan(/:(\d+)/).first.first.to_i
+    assert_equal 13, e.backtrace[0].scan(/:(\d+)/).first.first.to_i
   end
 
   class ActsLikeTag

data/vendor/plugins/haml/test/haml/html2haml_test.rb

@@ -1,9 +1,9 @@
 #!/usr/bin/env ruby
 require File.dirname(__FILE__) + '/../test_helper'
-require File.dirname(__FILE__) + '/html2haml/erb_tests'
 require 'haml/html'
 
 class Html2HamlTest < Test::Unit::TestCase
+
   def test_empty_render_should_remain_empty
     assert_equal '', render('')
   end
@@ -35,21 +35,14 @@ class Html2HamlTest < Test::Unit::TestCase
   end
 
   def test_should_have_pretty_attributes
-    assert_equal('%input{:name => "login", :type => "text"}/',
+    assert_equal_attributes('%input{ :type => "text", :name => "login" }',
       render('<input type="text" name="login" />'))
-    assert_equal('%meta{:content => "text/html", "http-equiv" => "Content-Type"}/',
+    assert_equal_attributes('%meta{ "http-equiv" => "Content-Type", :content => "text/html" }',
       render('<meta http-equiv="Content-Type" content="text/html" />'))
   end
 
-  def test_class_with_dot_and_hash
-    assert_equal('%div{:class => "foo.bar"}', render("<div class='foo.bar'></div>"))
-    assert_equal('%div{:class => "foo#bar"}', render("<div class='foo#bar'></div>"))
-    assert_equal('.foo.bar{:class => "foo#bar foo.bar"}', render("<div class='foo foo#bar bar foo.bar'></div>"))
-  end
-
-  def test_id_with_dot_and_hash
-    assert_equal('%div{:id => "foo.bar"}', render("<div id='foo.bar'></div>"))
-    assert_equal('%div{:id => "foo#bar"}', render("<div id='foo#bar'></div>"))
+  def test_sqml_comment
+    assert_equal "/\n  IE sucks", render('<!-- IE sucks -->')
   end
 
   def test_interpolation
@@ -57,7 +50,54 @@ class Html2HamlTest < Test::Unit::TestCase
   end
 
   def test_interpolation_in_attrs
-    assert_equal('%p{:foo => "\#{bar} baz"}', render('<p foo="#{bar} baz"></p>'))
+    assert_equal('%p{ :foo => "\#{bar} baz" }', render('<p foo="#{bar} baz"></p>'))
+  end
+
+  def test_rhtml
+    assert_equal '- foo = bar', render_rhtml('<% foo = bar %>')
+    assert_equal '- foo = bar', render_rhtml('<% foo = bar -%>')
+    assert_equal '= h @item.title', render_rhtml('<%=h @item.title %>')
+    assert_equal '= h @item.title', render_rhtml('<%=h @item.title -%>')
+  end
+  
+  def test_rhtml_with_html_special_chars
+    assert_equal '= 3 < 5 ? "OK" : "Your computer is b0rken"',
+      render_rhtml(%Q{<%= 3 < 5 ? "OK" : "Your computer is b0rken" %>})
+  end
+  
+  def test_rhtml_in_class_attribute
+    assert_equal "%div{ :class => dyna_class }\n  I have a dynamic attribute",
+      render_rhtml(%Q{<div class="<%= dyna_class %>">I have a dynamic attribute</div>})
+  end
+  
+  def test_rhtml_in_id_attribute
+    assert_equal "%div{ :id => dyna_id }\n  I have a dynamic attribute",
+      render_rhtml(%Q{<div id="<%= dyna_id %>">I have a dynamic attribute</div>})
+  end
+  
+  def test_rhtml_in_attribute_results_in_string_interpolation
+    assert_equal %(%div{ :id => "item_\#{i}" }\n  Ruby string interpolation FTW),
+      render_rhtml(%Q{<div id="item_<%= i %>">Ruby string interpolation FTW</div>})
+  end
+  
+  def test_rhtml_in_attribute_with_trailing_content
+    assert_equal %(%div{ :class => "\#{12}!" }\n  Bang!),
+      render_rhtml(%Q{<div class="<%= 12 %>!">Bang!</div>})
+  end
+  
+  def test_rhtml_in_html_escaped_attribute
+    assert_equal %(%div{ :class => "foo" }\n  Bang!),
+      render_rhtml(%Q{<div class="<%= "foo" %>">Bang!</div>})
+  end
+  
+  def test_rhtml_in_attribute_to_multiple_interpolations
+    assert_equal %(%div{ :class => "\#{12} + \#{13}" }\n  Math is super),
+      render_rhtml(%Q{<div class="<%= 12 %> + <%= 13 %>">Math is super</div>})
+  end
+  
+  def test_whitespace_eating_erb_tags
+    assert_equal %(- form_for),
+      render_rhtml(%Q{<%- form_for -%>})
   end
 
   def test_cdata
@@ -76,243 +116,13 @@ HAML
 HTML
   end
 
-  def test_self_closing_tag
-    assert_equal("%foo/", render("<foo />"))
-  end
-
-  def test_inline_text
-    assert_equal("%p foo", render("<p>foo</p>"))
-  end
-
-  def test_inline_comment
-    assert_equal("/ foo", render("<!-- foo -->"))
-    assert_equal(<<HAML.strip, render(<<HTML))
-/ foo
-%p bar
-HAML
-<!-- foo -->
-<p>bar</p>
-HTML
-  end
-
-  def test_non_inline_comment
-    assert_equal(<<HAML.rstrip, render(<<HTML))
-/
-  Foo
-  Bar
-HAML
-<!-- Foo
-Bar -->
-HTML
-  end
-
-  def test_non_inline_text
-    assert_equal(<<HAML.rstrip, render(<<HTML))
-%p
-  foo
-HAML
-<p>
-  foo
-</p>
-HTML
-    assert_equal(<<HAML.rstrip, render(<<HTML))
-%p
-  foo
-HAML
-<p>
-  foo</p>
-HTML
-    assert_equal(<<HAML.rstrip, render(<<HTML))
-%p
-  foo
-HAML
-<p>foo
-</p>
-HTML
+  def test_interpolation_in_rhtml
+    assert_equal('= "Foo #{bar} baz"', render_rhtml('<%= "Foo #{bar} baz" %>'))
   end
 
-  def test_script_tag
-    assert_equal(<<HAML.rstrip, render(<<HTML))
-:javascript
-  function foo() {
-      return "12" & "13";
-  }
-HAML
-<script type="text/javascript">
-    function foo() {
-        return "12" &amp; "13";
-    }
-</script>
-HTML
-  end
-
-  def test_script_tag_with_cdata
-    assert_equal(<<HAML.rstrip, render(<<HTML))
-:javascript
-  function foo() {
-    return "&amp;";
-  }
-HAML
-<script type="text/javascript">
-  <![CDATA[
-    function foo() {
-      return "&amp;";
-    }
-  ]]>
-</script>
-HTML
-  end
-
-  def test_pre
-    assert_equal(<<HAML.rstrip, render(<<HTML))
-%pre
-  :preserve
-    foo
-      bar
-    baz
-HAML
-<pre>foo
-  bar
-baz</pre>
-HTML
-  end
-
-  def test_pre_code
-    assert_equal(<<HAML.rstrip, render(<<HTML))
-%pre
-  %code
-    :preserve
-      foo
-        bar
-      baz
-HAML
-<pre><code>foo
-  bar
-baz</code></pre>
-HTML
-  end
-
-  def test_code_without_pre
-    assert_equal(<<HAML.rstrip, render(<<HTML))
-%code
-  foo
-  bar
-  baz
-HAML
-<code>foo
-  bar
-baz</code>
-HTML
-  end
-
-  def test_conditional_comment
-    assert_equal(<<HAML.rstrip, render(<<HTML))
-/[if foo]
-  bar
-  baz
-HAML
-<!--[if foo]>
-  bar
-  baz
-<![endif]-->
-HTML
-  end
-
-  def test_style_to_css_filter
-    assert_equal(<<HAML.rstrip, render_erb(<<HTML))
-:css
-  foo {
-      bar: baz;
-  }
-HAML
-<style type="text/css">
-    foo {
-        bar: baz;
-    }
-</style>
-HTML
-  end
-
-  def test_inline_conditional_comment
-    assert_equal(<<HAML.rstrip, render(<<HTML))
-/[if foo] bar baz
-HAML
-<!--[if foo]> bar baz <![endif]-->
-HTML
-  end
-
-  def test_minus_in_tag
-    assert_equal("%p - foo bar -", render("<p>- foo bar -</p>"))
-  end
-
-  def test_equals_in_tag
-    assert_equal("%p = foo bar =", render("<p>= foo bar =</p>"))
-  end
-
-  def test_hash_in_tag
-    assert_equal("%p # foo bar #", render("<p># foo bar #</p>"))
-  end
-
-  def test_comma_post_tag
-    assert_equal(<<HAML.rstrip, render(<<HTML))
-#foo
-  %span> Foo
-  ,
-  %span bar
-  Foo
-  %span> bar
-  ,
-  %span baz
-HAML
-<div id="foo">
-  <span>Foo</span>, <span>bar</span>
-  Foo<span>bar</span>, <span>baz</span>
-</div>
-HTML
-  end
-
-  def test_comma_post_tag_with_text_before
-    assert_equal(<<HAML.rstrip, render(<<HTML))
-#foo
-  Batch
-  = succeed "," do
-    %span Foo
-  %span Bar
-HAML
-<div id="foo">
-  Batch
-  <span>Foo</span>, <span>Bar</span>
-</div>
-HTML
-  end
-
-  begin
-    require 'haml/html/erb'
-    include ErbTests
-  rescue LoadError => e
-    puts "\n** Couldn't require #{e.message[/-- (.*)$/, 1]}, skipping some tests"
-  end
-
-  # Encodings
-
-  unless Haml::Util.ruby1_8?
-    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
+  def test_interpolation_in_rhtml_attrs
+    assert_equal('%p{ :foo => "#{bar} baz" }',
+      render_rhtml('<p foo="<%= "#{bar} baz" %>"></p>'))
   end
 
   # Regression Tests
@@ -330,7 +140,13 @@ HTML
     Haml::HTML.new(text, options).render.rstrip
   end
 
-  def render_erb(text)
-    render(text, :erb => true)
+  def render_rhtml(text)
+    render(text, :rhtml => true)
+  end
+
+  def assert_equal_attributes(expected, result)
+    expected_attr, result_attr = [expected, result].map { |s| s.gsub!(/\{ (.+) \}/, ''); $1.split(', ').sort }
+    assert_equal expected_attr, result_attr
+    assert_equal expected, result
   end
 end