middleman-core 3.2.2 → 3.3.0

data/lib/vendored-middleman-deps/padrino-helpers-0.11.4/test/test_format_helpers.rb

@@ -1,241 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/helper')
-require File.expand_path(File.dirname(__FILE__) + '/fixtures/markup_app/app')
-
-describe "FormatHelpers" do
-  include Padrino::Helpers::FormatHelpers
-
-  def app
-    MarkupDemo
-  end
-
-  def setup
-    Time.stubs(:now).returns(Time.utc(1983, 11, 9, 5))
-  end
-
-  context 'for #simple_format method' do
-    should "format simple text into html format" do
-      actual_text = simple_format("Here is some basic text...\n...with a line break.")
-      assert_equal true, actual_text.html_safe?
-      assert_equal "<p>Here is some basic text...\n<br />...with a line break.</p>", actual_text
-    end
-
-    should "format more text into html format" do
-      actual_text = simple_format("We want to put a paragraph...\n\n...right there.")
-      assert_equal "<p>We want to put a paragraph...</p>\n\n<p>...right there.</p>", actual_text
-    end
-
-    should "support defining a class for the paragraphs" do
-      actual_text = simple_format("Look me! A class!", :class => 'description')
-      assert_equal "<p class=\"description\">Look me! A class!</p>", actual_text
-    end
-
-    context 'wrapped in a custom tag' do
-      should "format simple text into html format" do
-        actual_text = simple_format("Here is some basic text...\n...with a line break.", :tag => :div)
-        assert_equal "<div>Here is some basic text...\n<br />...with a line break.</div>", actual_text
-      end
-
-      should "format more text into html format" do
-        actual_text = simple_format("We want to put a paragraph...\n\n...right there.", :tag => :div)
-        assert_equal "<div>We want to put a paragraph...</div>\n\n<div>...right there.</div>", actual_text
-      end
-
-      should "support defining a class for the paragraphs" do
-        actual_text = simple_format("Look me! A class!", :class => 'description', :tag => :div)
-        assert_equal "<div class=\"description\">Look me! A class!</div>", actual_text
-      end
-    end
-  end
-
-  context 'for #pluralize method' do
-    should "return singular count for 1 item collections" do
-      actual_text = pluralize(1, 'person')
-      assert_equal '1 person', actual_text
-    end
-    should "return plural count for empty collections" do
-      actual_text = pluralize(0, 'person')
-      assert_equal '0 people', actual_text
-    end
-    should "return plural count for many collections" do
-      actual_text =  pluralize(2, 'person')
-      assert_equal '2 people', actual_text
-    end
-    should "return pluralized word specified as argument" do
-      actual_text =  pluralize(3, 'person', 'users')
-      assert_equal '3 users', actual_text
-    end
-  end
-
-  context 'for #word_wrap method' do
-    should "return proper formatting for 8 max width" do
-      actual_text = word_wrap('Once upon a time', :line_width => 8)
-      assert_equal "Once\nupon a\ntime", actual_text
-    end
-    should "return proper formatting for 1 max width" do
-      actual_text = word_wrap('Once upon a time', :line_width => 1)
-      assert_equal "Once\nupon\na\ntime", actual_text
-    end
-    should "return proper formatting for default width" do
-      actual_text = word_wrap((1..50).to_a.join(" "))
-      assert_equal (1..30).to_a.join(" ") + "\n" + (31..50).to_a.join(" "), actual_text
-      actual_text = word_wrap((1..50).to_a.join(" "), 80)
-      assert_equal (1..30).to_a.join(" ") + "\n" + (31..50).to_a.join(" "), actual_text
-    end
-  end
-
-  context 'for #highlight method' do
-    should 'highligth with defaults' do
-      actual_text = highlight('Lorem ipsum dolor sit amet', 'dolor')
-      assert_equal 'Lorem ipsum <strong class="highlight">dolor</strong> sit amet', actual_text
-    end
-
-    should 'highlight with highlighter' do
-      actual_text = highlight('Lorem ipsum dolor sit amet', 'dolor', :highlighter => '<span class="custom">\1</span>')
-      assert_equal 'Lorem ipsum <span class="custom">dolor</span> sit amet', actual_text
-    end
-  end
-
-  context 'for #truncate method' do
-    should "support default truncation" do
-      actual_text = truncate("Once upon a time in a world far far away")
-      assert_equal "Once upon a time in a world...", actual_text
-    end
-    should "support specifying length" do
-      actual_text = truncate("Once upon a time in a world far far away", :length => 14)
-      assert_equal "Once upon a...", actual_text
-    end
-    should "support specifying omission text" do
-      actual_text = truncate("And they found that many people were sleeping better.", :length => 25, :omission => "(clipped)")
-      assert_equal "And they found t(clipped)", actual_text
-    end
-  end
-
-  context 'for #truncate_words method' do
-    should "support default truncation" do
-      actual_text = truncate_words("Long before books were made, people told stories. They told them to one another and to the children as they sat before the fire. Many of these stories were about interesting people, but most of them were about the ways of fairies and giants.")
-      assert_equal "Long before books were made, people told stories. They told them to one another and to the children as they sat before the fire. Many of these stories were about...", actual_text
-    end
-    should "support specifying length" do
-      actual_text = truncate_words("Once upon a time in a world far far away", :length => 8)
-      assert_equal "Once upon a time in a world far...", actual_text
-    end
-    should "support specifying omission text" do
-      actual_text = truncate_words("And they found that many people were sleeping better.", :length => 4, :omission => "(clipped)")
-      assert_equal "And they found that(clipped)", actual_text
-    end
-  end
-
-  context 'for #h and #h! method' do
-    should "escape the simple html" do
-      assert_equal '&lt;h1&gt;hello&lt;&#x2F;h1&gt;', h('<h1>hello</h1>')
-      assert_equal '&lt;h1&gt;hello&lt;&#x2F;h1&gt;', escape_html('<h1>hello</h1>')
-    end
-    should "escape all brackets, quotes and ampersands" do
-      assert_equal '&lt;h1&gt;&lt;&gt;&quot;&amp;demo&amp;&quot;&lt;&gt;&lt;&#x2F;h1&gt;', h('<h1><>"&demo&"<></h1>')
-    end
-    should "return default text if text is empty" do
-      assert_equal 'default', h!("", "default")
-      assert_equal '&nbsp;', h!("")
-    end
-    should "return text escaped if not empty" do
-      assert_equal '&lt;h1&gt;hello&lt;&#x2F;h1&gt;', h!('<h1>hello</h1>')
-    end
-    should "mark escaped text as safe" do
-      assert_equal false, '<h1>hello</h1>'.html_safe?
-      assert_equal true, h('<h1>hello</h1>').html_safe?
-      assert_equal true, h!("", "default").html_safe?
-    end
-  end
-
-  context 'for #time_ago_in_words method' do
-    should "less than 5 seconds" do
-      assert_equal 'less than 5 seconds', time_ago_in_words(Time.now, true)
-    end
-    should "less than 10 seconds" do
-      assert_equal 'less than 10 seconds', time_ago_in_words(Time.now-5, true)
-    end
-    should "less than 20 seconds" do
-      assert_equal 'less than 20 seconds', time_ago_in_words(Time.now-10, true)
-    end
-    should "less than a minute" do
-      assert_equal 'less than a minute', time_ago_in_words(Time.now-40, true)
-    end
-    should "2 minutes" do
-      assert_equal '2 minutes', time_ago_in_words(Time.now-120, true)
-    end
-    should "display today" do
-      assert_equal 'less than a minute', time_ago_in_words(Time.now)
-    end
-    should "display yesterday" do
-      assert_equal '1 day', time_ago_in_words(1.day.ago)
-    end
-    should "display tomorrow" do
-      assert_equal '1 day', time_ago_in_words(1.day.from_now)
-    end
-    should "return future number of days" do
-      assert_equal '4 days', time_ago_in_words(4.days.from_now)
-    end
-    should "return past days ago" do
-      assert_equal '4 days', time_ago_in_words(4.days.ago)
-    end
-    should "return formatted archived date" do
-      assert_equal '3 months', time_ago_in_words(100.days.ago)
-    end
-    should "return formatted archived year date" do
-      assert_equal 'over 1 year', time_ago_in_words(500.days.ago)
-    end
-    should 'display now as a minute ago' do
-      assert_equal '1 minute', time_ago_in_words(1.minute.ago)
-    end
-    should "display a few minutes ago" do
-      assert_equal '4 minutes', time_ago_in_words(4.minute.ago)
-    end
-    should "display an hour ago" do
-      assert_equal 'about 1 hour', time_ago_in_words(1.hour.ago + 5.minutes.ago.sec)
-    end
-    should "display a few hours ago" do
-      assert_equal 'about 3 hours', time_ago_in_words(3.hour.ago + 5.minutes.ago.sec)
-    end
-    should "display a day ago" do
-      assert_equal '1 day', time_ago_in_words(1.day.ago)
-    end
-    should "display a few days ago" do
-      assert_equal '5 days', time_ago_in_words(5.days.ago - 5.minutes.ago.sec)
-    end
-    should "display a month ago" do
-      assert_equal 'about 1 month', time_ago_in_words(32.days.ago + 5.minutes.ago.sec)
-    end
-    should "display a few months ago" do
-      assert_equal '6 months', time_ago_in_words(180.days.ago - 5.minutes.ago.sec)
-    end
-    should "display a year ago" do
-      assert_equal 'about 1 year', time_ago_in_words(365.days.ago - 5.minutes.ago.sec)
-    end
-    should "display a few years ago" do
-      assert_equal 'over 7 years', time_ago_in_words(2800.days.ago - 5.minutes.ago.sec)
-    end
-  end
-
-  context 'for #js_escape_html method' do
-    should "escape double quotes" do
-      assert_equal "\\\"hello\\\"", js_escape_html('"hello"')
-      assert_equal "\\\"hello\\\"", js_escape_html(ActiveSupport::SafeBuffer.new('"hello"'))
-    end
-    should "escape single quotes" do
-      assert_equal "\\'hello\\'", js_escape_html("'hello'")
-      assert_equal "\\'hello\\'", js_escape_html(ActiveSupport::SafeBuffer.new("'hello'"))
-    end
-    should "escape html tags and breaks" do
-      assert_equal "\\n\\n<p>hello<\\/p>\\n", js_escape_html("\n\r<p>hello</p>\r\n")
-      assert_equal "\\n\\n<p>hello<\\/p>\\n", js_escape_html(ActiveSupport::SafeBuffer.new("\n\r<p>hello</p>\r\n"))
-    end
-    should "escape data-confirm attribute" do
-      assert_equal "<data-confirm=\\\"are you sure\\\">", js_escape_html("<data-confirm=\"are you sure\">")
-      assert_equal "<data-confirm=\\\"are you sure\\\">", js_escape_html(ActiveSupport::SafeBuffer.new("<data-confirm=\"are you sure\">"))
-    end
-    should "keep html_safe content html_safe" do
-      assert_equal false, js_escape_html('"hello"').html_safe?
-      assert_equal true, js_escape_html(ActiveSupport::SafeBuffer.new('"hello"')).html_safe?
-    end
-  end
-end

data/lib/vendored-middleman-deps/padrino-helpers-0.11.4/test/test_locale.rb

@@ -1,20 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/helper')
-
-describe "Locale Helpers" do
-  Dir[File.expand_path("../../lib/padrino-helpers/locale/*.yml", __FILE__)].each do |file|
-    base_original = YAML.load_file(file)
-    name = File.basename(file, '.yml')
-    should "should have correct locale for #{name}" do
-      base = base_original[name]['number']['format']
-      assert !base['separator'].nil?
-      assert !base['delimiter'].nil?
-      assert !base['precision'].nil?
-      base = base_original[name]['number']['currency']['format']
-      assert !base['format'].nil?
-      assert !base['unit'].nil?
-      assert !base['separator'].nil?
-      assert !base['delimiter'].nil?
-      assert !base['precision'].nil?
-    end
-  end
-end

data/lib/vendored-middleman-deps/padrino-helpers-0.11.4/test/test_number_helpers.rb

@@ -1,143 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/helper')
-require File.expand_path(File.dirname(__FILE__) + '/fixtures/markup_app/app')
-
-describe "NumberHelpers" do
-  include Padrino::Helpers::NumberHelpers
-
-  def app
-    MarkupDemo
-  end
-
-  def kilobytes(number)
-    number * 1024
-  end
-
-  def megabytes(number)
-    kilobytes(number) * 1024
-  end
-
-  def gigabytes(number)
-    megabytes(number) * 1024
-  end
-
-  def terabytes(number)
-    gigabytes(number) * 1024
-  end
-
-  context 'for number helpers functionality' do
-
-    should 'display number_to_currency' do
-      assert_equal "$1,234,567,890.50",        number_to_currency(1234567890.50)
-      assert_equal "$1,234,567,890.51",        number_to_currency(1234567890.506)
-      assert_equal "$1,234,567,892",           number_to_currency(1234567891.50, {:precision => 0})
-      assert_equal "$1,234,567,890.5",         number_to_currency(1234567890.50, {:precision => 1})
-      assert_equal "£1234567890,50",     number_to_currency(1234567890.50, {:unit => "£", :separator => ",", :delimiter => ""})
-      assert_equal "$1,234,567,890.50",        number_to_currency("1234567890.50")
-      assert_equal "1,234,567,890.50 Kč", number_to_currency("1234567890.50", {:unit => "Kč", :format => "%n %u"})
-      assert_equal "$x",                       number_to_currency("x")
-
-      assert_nil number_to_currency(nil)
-    end
-
-    should 'display  number_to_percentage' do
-      assert_equal "100.000%",   number_to_percentage(100)
-      assert_equal "100%",       number_to_percentage(100, {:precision => 0})
-      assert_equal "302.06%",    number_to_percentage(302.0574, {:precision => 2})
-      assert_equal "100.000%",   number_to_percentage("100")
-      assert_equal "1000.000%",  number_to_percentage("1000")
-      assert_equal "x%",         number_to_percentage("x")
-      assert_equal "1.000,000%", number_to_percentage(1000, :delimiter => '.', :separator => ',')
-
-      assert_nil number_to_percentage(nil)
-    end
-
-    should 'display  number_with_delimiter' do
-      assert_equal "12,345,678",        number_with_delimiter(12345678)
-      assert_equal "0",                 number_with_delimiter(0)
-      assert_equal "123",               number_with_delimiter(123)
-      assert_equal "123,456",           number_with_delimiter(123456)
-      assert_equal "123,456.78",        number_with_delimiter(123456.78)
-      assert_equal "123,456.789",       number_with_delimiter(123456.789)
-      assert_equal "123,456.78901",     number_with_delimiter(123456.78901)
-      assert_equal "123,456,789.78901", number_with_delimiter(123456789.78901)
-      assert_equal "0.78901",           number_with_delimiter(0.78901)
-      assert_equal "123,456.78",        number_with_delimiter("123456.78")
-      assert_equal "x",                 number_with_delimiter("x")
-
-      assert_nil number_with_delimiter(nil)
-    end
-
-    should 'display number_with_delimiter with options' do
-      assert_equal '12 345 678',    number_with_delimiter(12345678, :delimiter => ' ')
-      assert_equal '12,345,678-05', number_with_delimiter(12345678.05, :separator => '-')
-      assert_equal '12.345.678,05', number_with_delimiter(12345678.05, :separator => ',', :delimiter => '.')
-      assert_equal '12.345.678,05', number_with_delimiter(12345678.05, :delimiter => '.', :separator => ',')
-    end
-
-    should 'display number_with_precision' do
-      assert_equal "111.235",    number_with_precision(111.2346)
-      assert_equal "31.83",      number_with_precision(31.825, :precision => 2)
-      assert_equal "111.23",     number_with_precision(111.2346, :precision => 2)
-      assert_equal "111.00",     number_with_precision(111, :precision => 2)
-      assert_equal "111.235",    number_with_precision("111.2346")
-      assert_equal "31.83",      number_with_precision("31.825", :precision => 2)
-      assert_equal "3268",       number_with_precision((32.6751 * 100.00), :precision => 0)
-      assert_equal "112",        number_with_precision(111.50, :precision => 0)
-      assert_equal "1234567892", number_with_precision(1234567891.50, :precision => 0)
-
-      # Return non-numeric params unchanged.
-      assert_equal "x", number_with_precision("x")
-      assert_nil number_with_precision(nil)
-    end
-
-    should 'display number_with_precision with custom delimiter and separator' do
-      assert_equal '31,83',     number_with_precision(31.825, :precision => 2, :separator => ',')
-      assert_equal '1.231,83',  number_with_precision(1231.825, :precision => 2, :separator => ',', :delimiter => '.')
-    end
-
-    should 'display number_to_human_size' do
-      assert_equal '0 Bytes',   number_to_human_size(0)
-      assert_equal '1 Byte',    number_to_human_size(1)
-      assert_equal '3 Bytes',   number_to_human_size(3.14159265)
-      assert_equal '123 Bytes', number_to_human_size(123.0)
-      assert_equal '123 Bytes', number_to_human_size(123)
-      assert_equal '1.2 KB',    number_to_human_size(1234)
-      assert_equal '12.1 KB',   number_to_human_size(12345)
-      assert_equal '1.2 MB',    number_to_human_size(1234567)
-      assert_equal '1.1 GB',    number_to_human_size(1234567890)
-      assert_equal '1.1 TB',    number_to_human_size(1234567890123)
-      assert_equal '1025 TB',   number_to_human_size(terabytes(1025))
-      assert_equal '444 KB',    number_to_human_size(kilobytes(444))
-      assert_equal '1023 MB',   number_to_human_size(megabytes(1023))
-      assert_equal '3 TB',      number_to_human_size(terabytes(3))
-      assert_equal '1.18 MB',   number_to_human_size(1234567, :precision => 2)
-      assert_equal '3 Bytes',   number_to_human_size(3.14159265, :precision => 4)
-      assert_equal '123 Bytes', number_to_human_size("123")
-      assert_equal '1.01 KB',   number_to_human_size(kilobytes(1.0123), :precision => 2)
-      assert_equal '1.01 KB',   number_to_human_size(kilobytes(1.0100), :precision => 4)
-      assert_equal '10 KB',     number_to_human_size(kilobytes(10.000), :precision => 4)
-      assert_equal '1 Byte',    number_to_human_size(1.1)
-      assert_equal '10 Bytes',  number_to_human_size(10)
-
-      assert_nil number_to_human_size(nil)
-    end
-
-    should 'display number_to_human_size with options' do
-      assert_equal '1.18 MB', number_to_human_size(1234567, :precision => 2)
-      assert_equal '3 Bytes', number_to_human_size(3.14159265, :precision => 4)
-      assert_equal '1.01 KB', number_to_human_size(kilobytes(1.0123), :precision => 2)
-      assert_equal '1.01 KB', number_to_human_size(kilobytes(1.0100), :precision => 4)
-      assert_equal '10 KB',   number_to_human_size(kilobytes(10.000), :precision => 4)
-      assert_equal '1 TB',    number_to_human_size(1234567890123, :precision => 0)
-      assert_equal '500 MB',  number_to_human_size(524288000, :precision => 0)
-      assert_equal '40 KB',   number_to_human_size(41010, :precision => 0)
-      assert_equal '40 KB',   number_to_human_size(41100, :precision => 0)
-    end
-
-    should 'display number_to_human_size with custom delimiter and separator' do
-      assert_equal '1,01 KB',     number_to_human_size(kilobytes(1.0123), :precision => 2, :separator => ',')
-      assert_equal '1,01 KB',     number_to_human_size(kilobytes(1.0100), :precision => 4, :separator => ',')
-      assert_equal '1.000,1 TB',  number_to_human_size(terabytes(1000.1), :delimiter => '.', :separator => ',')
-    end
-  end
-end

data/lib/vendored-middleman-deps/padrino-helpers-0.11.4/test/test_output_helpers.rb

@@ -1,154 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/helper')
-require File.expand_path(File.dirname(__FILE__) + '/fixtures/markup_app/app')
-
-describe "OutputHelpers" do
-  def app
-    MarkupDemo
-  end
-
-  context 'for #content_for method' do
-    should 'work for erb templates' do
-      visit '/erb/content_for'
-      assert_have_selector '.demo h1', :content => "This is content yielded from a content_for"
-      assert_have_selector '.demo2 h1', :content => "This is content yielded with name Johnny Smith"
-    end
-
-    should "work for haml templates" do
-      visit '/haml/content_for'
-      assert_have_selector '.demo h1', :content => "This is content yielded from a content_for"
-      assert_have_selector '.demo2 h1', :content => "This is content yielded with name Johnny Smith"
-    end
-
-    should "work for slim templates" do
-      visit '/slim/content_for'
-      assert_have_selector '.demo h1', :content => "This is content yielded from a content_for"
-      assert_have_selector '.demo2 h1', :content => "This is content yielded with name Johnny Smith"
-    end
-  end # content_for
-
-  context "for #content_for? method" do
-    should 'work for erb templates' do
-      visit '/erb/content_for'
-      assert_have_selector '.demo_has_content', :content => "true"
-      assert_have_selector '.fake_has_content', :content => "false"
-    end
-
-    should "work for haml templates" do
-      visit '/haml/content_for'
-      assert_have_selector '.demo_has_content', :content => "true"
-      assert_have_selector '.fake_has_content', :content => "false"
-    end
-
-    should "work for slim templates" do
-      visit '/slim/content_for'
-      assert_have_selector '.demo_has_content', :content => "true"
-      assert_have_selector '.fake_has_content', :content => "false"
-    end
-  end # content_for?
-
-  context 'for #capture_html method' do
-    should "work for erb templates" do
-      visit '/erb/capture_concat'
-      assert_have_selector 'p span', :content => "Captured Line 1"
-      assert_have_selector 'p span', :content => "Captured Line 2"
-    end
-
-    should "work for haml templates" do
-      visit '/haml/capture_concat'
-      assert_have_selector 'p span', :content => "Captured Line 1"
-      assert_have_selector 'p span', :content => "Captured Line 2"
-    end
-
-    should "work for slim templates" do
-      visit '/slim/capture_concat'
-      assert_have_selector 'p span', :content => "Captured Line 1"
-      assert_have_selector 'p span', :content => "Captured Line 2"
-    end
-  end
-
-  context 'for #concat_content method' do
-    should "work for erb templates" do
-      visit '/erb/capture_concat'
-      assert_have_selector 'p', :content => "Concat Line 3", :count => 1
-    end
-
-    should "work for haml templates" do
-      visit '/haml/capture_concat'
-      assert_have_selector 'p', :content => "Concat Line 3", :count => 1
-    end
-
-    should "work for slim templates" do
-      visit '/slim/capture_concat'
-      # TODO Get Slim concat working
-      # assert_have_selector 'p', :content => "Concat Line 3", :count => 1
-    end
-  end
-
-  context 'for #block_is_template?' do
-    should "work for erb templates" do
-      visit '/erb/capture_concat'
-      assert_have_selector 'p', :content => "The erb block passed in is a template", :class => 'is_template'
-      # TODO Get ERB template detection working (fix block_is_erb? method)
-      # assert_have_no_selector 'p', :content => "The ruby block passed in is a template", :class => 'is_template'
-    end
-
-    should "work for haml templates" do
-      visit '/haml/capture_concat'
-      assert_have_selector 'p', :content => "The haml block passed in is a template", :class => 'is_template'
-      assert_have_no_selector 'p', :content => "The ruby block passed in is a template", :class => 'is_template'
-    end
-
-    should "work for slim templates" do
-      visit '/slim/capture_concat'
-      # TODO Get Slim template detection working
-      # assert_have_selector 'p', :content => "The slim block passed in is a template", :class => 'is_template'
-      assert_have_no_selector 'p', :content => "The ruby block passed in is a template", :class => 'is_template'
-    end
-  end
-
-  context 'for #current_engine method' do
-    should 'detect correctly current engine for erb' do
-      visit '/erb/current_engine'
-      assert_have_selector 'p.start', :content => "erb"
-      assert_have_selector 'p.haml',  :content => "haml"
-      assert_have_selector 'p.erb',   :content => "erb"
-      assert_have_selector 'p.slim',  :content => "slim"
-      assert_have_selector 'p.end',   :content => "erb"
-    end
-
-    should 'detect correctly current engine for haml' do
-      visit '/haml/current_engine'
-      assert_have_selector 'p.start', :content => "haml"
-      assert_have_selector 'p.haml',  :content => "haml"
-      assert_have_selector 'p.erb',   :content => "erb"
-      assert_have_selector 'p.slim',  :content => "slim"
-      assert_have_selector 'p.end',   :content => "haml"
-    end
-
-    should 'detect correctly current engine for slim' do
-      visit '/slim/current_engine'
-      assert_have_selector 'p.start', :content => "slim"
-      assert_have_selector 'p.haml',  :content => "haml"
-      assert_have_selector 'p.erb',   :content => "erb"
-      assert_have_selector 'p.slim',  :content => "slim"
-      assert_have_selector 'p.end',   :content => "slim"
-    end
-  end
-
-  context 'for #partial method in simple sinatra application' do
-    should 'properly output in erb' do
-      visit '/erb/simple_partial'
-      assert_have_selector 'p.erb',  :content => "erb"
-    end
-
-    should 'properly output in haml' do
-      visit '/haml/simple_partial'
-      assert_have_selector 'p.haml',  :content => "haml"
-    end
-
-    should 'properly output in slim' do
-      visit '/slim/simple_partial'
-      assert_have_selector 'p.slim',  :content => "slim"
-    end
-  end
-end