spree 0.7.1 → 0.8.0

data/vendor/gems/haml-2.1.0/test/haml/helper_test.rb

@@ -0,0 +1,224 @@
+#!/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
+end
+
+class HelperTest < Test::Unit::TestCase
+  Post = Struct.new('Post', :body)
+  
+  def setup
+    @base = ActionView::Base.new
+    @base.controller = ActionController::Base.new
+    @base.instance_variable_set('@post', Post.new("Foo bar\nbaz"))
+  end
+
+  def render(text, options = {})
+    if options == :action_view
+      @base.render :inline => text, :type => :haml
+    else
+      scope = options.delete :scope_object
+      Haml::Engine.new(text, options).to_html(scope ? scope : Object.new)
+    end
+  end
+
+  def test_flatten
+    assert_equal("FooBar", Haml::Helpers.flatten("FooBar"))
+
+    assert_equal("FooBar", Haml::Helpers.flatten("Foo\rBar"))
+
+    assert_equal("Foo&#x000A;Bar", Haml::Helpers.flatten("Foo\nBar"))
+
+    assert_equal("Hello&#x000A;World!&#x000A;YOU ARE FLAT?&#x000A;OMGZ!",
+      Haml::Helpers.flatten("Hello\nWorld!\nYOU ARE \rFLAT?\n\rOMGZ!"))
+  end
+
+  def test_list_of_should_render_correctly
+    assert_equal("<li>1</li>\n<li>2</li>\n", render("= list_of([1, 2]) do |i|\n  = i"))
+    assert_equal("<li>[1]</li>\n", render("= list_of([[1]]) do |i|\n  = i.inspect"))
+    assert_equal("<li>\n  <h1>Fee</h1>\n  <p>A word!</p>\n</li>\n<li>\n  <h1>Fi</h1>\n  <p>A word!</p>\n</li>\n<li>\n  <h1>Fo</h1>\n  <p>A word!</p>\n</li>\n<li>\n  <h1>Fum</h1>\n  <p>A word!</p>\n</li>\n",
+      render("= list_of(['Fee', 'Fi', 'Fo', 'Fum']) do |title|\n  %h1= title\n  %p A word!"))
+  end
+
+  def test_buffer_access
+    assert(render("= buffer") =~ /#<Haml::Buffer:0x[a-z0-9]+>/)
+    assert_equal(render("= (buffer == _hamlout)"), "true\n")
+  end
+
+  def test_tabs
+    assert_equal("foo\n  bar\nbaz\n", render("foo\n- tab_up\nbar\n- tab_down\nbaz"))
+    assert_equal("          <p>tabbed</p>\n", render("- buffer.tabulation=5\n%p tabbed"))
+  end
+  
+  def test_helpers_dont_leak
+    # Haml helpers shouldn't be accessible from ERB
+    render("foo")
+    proper_behavior = false
+
+    begin
+      ActionView::Base.new.render(:inline => "<%= flatten('Foo\\nBar') %>")
+    rescue NoMethodError
+      proper_behavior = true
+    end
+    assert(proper_behavior)
+
+    begin
+      ActionView::Base.new.render(:inline => "<%= concat('foo') %>")
+    rescue ArgumentError, NameError
+      proper_behavior = true
+    end    
+    assert(proper_behavior)
+  end
+  
+  def test_action_view_included
+    assert(Haml::Helpers.action_view?)
+  end
+  
+  def test_form_tag
+    # This is usually provided by ActionController::Base.
+    def @base.protect_against_forgery?; false; end
+    result = render("- form_tag 'foo' do\n  %p bar\n  %strong baz", :action_view)
+    should_be = "<form action=\"foo\" method=\"post\">\n  <p>bar</p>\n  <strong>baz</strong>\n</form>\n"
+    assert_equal(should_be, result)
+  end
+
+  def test_text_area
+    assert_equal(%(<textarea id="body" name="body">Foo&#x000A;Bar&#x000A; Baz&#x000A;   Boom</textarea>\n),
+                 render('= text_area_tag "body", "Foo\nBar\n Baz\n   Boom"', :action_view))
+
+    assert_equal(%(<textarea cols="40" id="post_body" name="post[body]" rows="20">Foo bar&#x000A;baz</textarea>\n),
+                 render('= text_area :post, :body', :action_view))    
+
+    assert_equal(%(<pre>Foo bar&#x000A;   baz</pre>\n),
+                 render('= content_tag "pre", "Foo bar\n   baz"', :action_view))    
+  end
+  
+  def test_capture_haml
+    assert_equal("\"<p>13</p>\\n\"\n", render("- foo = capture_haml(13) do |a|\n  %p= a\n= foo.dump"))
+  end
+
+  def test_content_tag_block
+    assert_equal(<<HTML.strip, render(<<HAML, :action_view))
+<div><p>bar</p>
+<strong>bar</strong>
+</div>
+HTML
+- content_tag :div do
+  %p bar
+  %strong bar
+HAML
+  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
+
+  def test_haml_tag_autoclosed_tags_are_closed
+    assert_equal("<br class='foo' />\n", render("- haml_tag :br, :class => 'foo'"))
+  end
+
+  def test_haml_tag_non_autoclosed_tags_arent_closed
+    assert_equal("<p></p>\n", render("- haml_tag :p"))
+  end
+
+  def test_haml_tag_renders_text_on_a_single_line
+    assert_equal("<p>#{'a' * 100}</p>\n", render("- haml_tag :p, 'a' * 100"))
+  end
+
+  def test_haml_tag_raises_error_for_multiple_content
+    assert_raise(Haml::Error) { render("- haml_tag :p, 'foo' do\n  bar") }
+  end
+
+  def test_haml_tag_flags
+    assert_equal("<p />\n", render("- haml_tag :p, :/"))
+    assert_equal("<p>kumquat</p>\n", render("- haml_tag :p, :< do\n  kumquat"))
+
+    assert_raise(Haml::Error) { render("- haml_tag :p, 'foo', :/") }
+    assert_raise(Haml::Error) { render("- haml_tag :p, :/ do\n  foo") }
+  end
+
+  def test_is_haml
+    assert(!ActionView::Base.new.is_haml?)
+    assert_equal("true\n", render("= is_haml?"))
+    assert_equal("true\n", render("= is_haml?", :action_view))
+    assert_equal("false", @base.render(:inline => '<%= is_haml? %>'))
+    assert_equal("false\n", render("= render :inline => '<%= is_haml? %>'", :action_view))
+  end
+
+  def test_page_class
+    controller = Struct.new(:controller_name, :action_name).new('troller', 'tion')
+    scope = Struct.new(:controller).new(controller)
+    result = render("%div{:class => page_class} MyDiv", :scope_object => scope)
+    expected = "<div class='troller tion'>MyDiv</div>\n"
+    assert_equal expected, result
+  end
+
+  def test_indented_capture
+    assert_equal("  \n  Foo\n  ", @base.render(:inline => "  <% res = capture do %>\n  Foo\n  <% end %><%= res %>"))
+  end
+
+  def test_capture_deals_properly_with_collections
+    Haml::Helpers.module_eval do 
+      def trc(collection, &block)
+        collection.each do |record|
+          haml_concat capture_haml(record, &block)
+        end
+      end
+    end
+
+    assert_equal("1\n\n2\n\n3\n\n", render("- trc([1, 2, 3]) do |i|\n  = i.inspect"))
+  end
+
+  def test_find_and_preserve_with_block
+    assert_equal("<pre>Foo&#x000A;Bar</pre>\nFoo\nBar\n",
+                 render("= find_and_preserve do\n  %pre\n    Foo\n    Bar\n  Foo\n  Bar"))
+  end
+
+  def test_preserve_with_block
+    assert_equal("<pre>Foo&#x000A;Bar</pre>&#x000A;Foo&#x000A;Bar\n",
+                 render("= preserve do\n  %pre\n    Foo\n    Bar\n  Foo\n  Bar"))
+  end
+
+  def test_init_haml_helpers
+    context = Object.new
+    class << context
+      include Haml::Helpers
+    end
+    context.init_haml_helpers
+
+    result = context.capture_haml do
+      context.haml_tag :p, :attr => "val" do
+        context.haml_concat "Blah"
+      end
+    end
+
+    assert_equal("<p attr='val'>\n  Blah\n</p>\n", result)
+  end
+
+  def test_non_haml
+    assert_equal("false\n", render("= non_haml { is_haml? }"))
+  end
+
+  def test_content_tag_nested
+    assert_equal "<span><div>something</div></span>", render("= nested_tag", :action_view).strip
+  end
+  
+  class ActsLikeTag
+    # We want to be able to have people include monkeypatched ActionView helpers
+    # without redefining is_haml?.
+    # This is accomplished via Object#is_haml?, and this is a test for it.
+    include ActionView::Helpers::TagHelper
+    def to_s
+      content_tag :p, 'some tag content'
+    end
+  end
+
+  def test_random_class_includes_tag_helper
+    assert_equal "<p>some tag content</p>", ActsLikeTag.new.to_s
+  end
+end
+

data/vendor/gems/haml-2.1.0/test/haml/html2haml_test.rb

@@ -0,0 +1,92 @@
+#!/usr/bin/env ruby
+require File.dirname(__FILE__) + '/../test_helper'
+require 'haml/html'
+
+class Html2HamlTest < Test::Unit::TestCase
+
+  def test_empty_render_should_remain_empty
+    assert_equal '', render('')
+  end
+
+  def test_id_and_class_should_be_removed_from_hash
+    assert_equal '%span#foo.bar', render('<span id="foo" class="bar"> </span>')
+  end
+
+  def test_no_tag_name_for_div_if_class_or_id_is_present
+    assert_equal '#foo', render('<div id="foo"> </div>')
+    assert_equal '.foo', render('<div class="foo"> </div>')
+  end
+
+  def test_multiple_class_names
+    assert_equal '.foo.bar.baz', render('<div class=" foo  bar  baz "> </div>')
+  end
+
+  def test_should_have_pretty_attributes
+    assert_equal_attributes('%input{ :type => "text", :name => "login" }',
+      render('<input type="text" name="login" />'))
+    assert_equal_attributes('%meta{ "http-equiv" => "Content-Type", :content => "text/html" }',
+      render('<meta http-equiv="Content-Type" content="text/html" />'))
+  end
+
+  def test_sqml_comment
+    assert_equal "/\n  IE sucks", render('<!-- IE sucks -->')
+  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_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
+
+  protected
+
+  def render(text, options = {})
+    Haml::HTML.new(text, options).render.rstrip
+  end
+
+  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

data/vendor/gems/haml-2.1.0/test/haml/markaby/standard.mab

@@ -0,0 +1,52 @@
+self << '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">'
+html(:xmlns=>'http://www.w3.org/1999/xhtml', 'xml:lang'=>'en-US') do
+  head do
+    title "Hampton Catlin Is Totally Awesome"
+    meta("http-equiv" => "Content-Type", :content => "text/html; charset=utf-8")
+  end
+  body do
+    # You're In my house now!
+    div :class => "header" do
+      self << %|Yes, ladies and gentileman. He is just that egotistical.
+      Fantastic! This should be multi-line output
+      The question is if this would translate! Ahah!|
+      self << 1 + 9 + 8 + 2 #numbers should work and this should be ignored
+    end
+    div(:id => "body") { self << "Quotes should be loved! Just like people!"}
+    120.times do |number|
+      number
+    end
+    self << "Wow.|"
+    p do
+      self << "Holy cow        " + 
+        "multiline       " +       
+        "tags!           " + 
+        "A pipe (|) even!"   
+      self << [1, 2, 3].collect { |n| "PipesIgnored|" }
+      self << [1, 2, 3].collect { |n|     
+          n.to_s                    
+        }.join("|")                
+    end
+    div(:class => "silent") do
+      foo = String.new
+      foo << "this"
+      foo << " shouldn't"
+      foo << " evaluate"
+      self << foo + " but now it should!"
+      # Woah crap a comment!
+    end
+    # That was a line that shouldn't close everything.
+    ul(:class => "really cool") do
+      ('a'..'f').each do |a|
+        li a
+      end
+    end
+    div((@should_eval = "with this text"), :id => "combo", :class => "of_divs_with_underscore")
+    [ 104, 101, 108, 108, 111 ].map do |byte|
+      byte.chr
+    end
+    div(:class => "footer") do
+      strong("This is a really long ruby quote. It should be loved and wrapped because its more than 50 characters. This value may change in the future and this test may look stupid. \nSo, I'm just making it *really* long. God, I hope this works", :class => "shout")
+    end
+  end
+end

data/vendor/gems/haml-2.1.0/test/haml/mocks/article.rb

@@ -0,0 +1,6 @@
+class Article
+  attr_accessor :id, :title, :body
+  def initialize
+    @id, @title, @body = 1, 'Hello', 'World'
+  end
+end

data/vendor/gems/haml-2.1.0/test/haml/results/content_for_layout.xhtml

@@ -0,0 +1,15 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html>
+  <head></head>
+  <body>
+    <div id='content'>
+      Lorem ipsum dolor sit amet
+    </div>
+    <div id='yieldy'>
+      Lorem ipsum dolor sit amet
+    </div>
+    <div id='nosym'>
+      Lorem ipsum dolor sit amet
+    </div>
+  </body>
+</html>

data/vendor/gems/haml-2.1.0/test/haml/results/eval_suppressed.xhtml

@@ -0,0 +1,9 @@
+<p></p>
+<p></p>
+<h1>Me!</h1>
+<div id='foo'>
+  <p id='bar'>All</p>
+  <br />
+  <p class='baz'>This</p>
+  Should render
+</div>

data/vendor/gems/haml-2.1.0/test/haml/results/filters.xhtml

@@ -0,0 +1,62 @@
+<style>
+  /* line 1 */
+  p { border-style: dotted; border-width: 22px; border-color: #ff00ff; }
+  
+  /* line 6 */
+  h1 { font-weight: normal; }
+</style>
+TESTING HAHAHAHA!
+<p>
+  <script type='text/javascript'>
+    //<![CDATA[
+      function newline(str) {
+        return "\n" + str;
+      }
+    //]]>
+  </script>
+</p>
+This
+  Is
+    Plain
+      Text
+        %strong right?
+ #{not interpolated}
+ \3
+ \#{also not}
+ \\
+<p>
+  <pre>This pre is pretty deeply&#x000A;      nested.&#x000A;   Does interpolation work?
+    This one is, too.&#x000A;Nested, that is.&#x000A;</pre>
+</p>
+<ul>
+
+  <li>a</li>
+
+  <li>b</li>
+
+  <li>c</li>
+
+  <li>d</li>
+
+  <li>e</li>
+
+  <li>f</li>
+
+  <li>g</li>
+
+  <li>h</li>
+
+  <li>i</li>
+
+  <li>j</li>
+
+
+
+</ul>
+<div class='res'>178</div>
+Text!
+Hello, World!
+How are you doing today?
+&lt;div class=&quot;foo&quot;&gt;
+  &lt;p&gt;I think &amp;mdash; or do I?&lt;/p&gt;
+&lt;/div&gt;