greenmat 3.2.2.2 → 3.5.1.2

data/test/html_toc_render_test.rb

@@ -3,24 +3,28 @@ require 'test_helper'
 
 class HTMLTOCRenderTest < Greenmat::TestCase
   def setup
-    @render = Greenmat::Render::HTML_TOC
-    @markdown = "# A title \n## A __nice__ subtitle\n## Another one \n### A sub-sub-title"
+    @renderer = Greenmat::Render::HTML_TOC
+    @markdown = <<-Markdown.strip_heredoc
+      # A title
+      ## A __nice__ subtitle
+      ## Another one
+      ### A sub-sub-title
+      ### 見出し
+    Markdown
   end
 
   def test_simple_toc_render
-    renderer = Greenmat::Markdown.new(@render)
-    output = renderer.render(@markdown).strip
+    output = render(@markdown)
 
     assert output.start_with?("<ul>")
     assert output.end_with?("</ul>")
 
     assert_equal 3, output.scan("<ul>").length
-    assert_equal 4, output.scan("<li>").length
+    assert_equal 5, output.scan("<li>").length
   end
 
   def test_granular_toc_render
-    renderer = Greenmat::Markdown.new(@render.new(nesting_level: 2))
-    output = renderer.render(@markdown).strip
+    output = render(@markdown, with: { nesting_level: 2 })
 
     assert output.start_with?("<ul>")
     assert output.end_with?("</ul>")
@@ -29,21 +33,80 @@ class HTMLTOCRenderTest < Greenmat::TestCase
     assert !output.include?("A sub-sub title")
   end
 
+  def test_granular_toc_render_with_range
+    output = render(@markdown, with: { nesting_level: 2..5 }).strip
+
+    assert output.start_with?("<ul>")
+    assert output.end_with?("</ul>")
+
+    assert output.match("Another one")
+    assert output.match("A sub-sub-title")
+    assert output.match("見出し")
+
+    refute output.match("A title")
+    refute output.match("A really tiny title")
+  end
+
   def test_toc_heading_id
-    renderer = Greenmat::Markdown.new(@render)
-    output = renderer.render(@markdown)
+    output = render(@markdown)
 
     assert_match /a-title/, output
     assert_match /a-nice-subtitle/, output
     assert_match /another-one/, output
     assert_match /a-sub-sub-title/, output
+    # the part number length varies depending on architecture (32b or 64b)
+    assert_match /part-(37870bf)?a194139f/, output
   end
 
   def test_toc_heading_with_hyphen_and_equal
-    renderer = Greenmat::Markdown.new(@render)
-    output = renderer.render("# Hello World\n\n-\n\n=")
+    output = render("# Hello World\n\n-\n\n=")
 
     assert_equal 1, output.scan("<li>").length
     assert !output.include?('<a href=\"#\"></a>')
   end
+
+  def test_anchor_generation_with_edge_cases
+    # Imported from ActiveSupport::Inflector#parameterize's tests
+    titles = {
+      "Donald E. Knuth"                     => "donald-e-knuth",
+      "Random text with *(bad)* characters" => "random-text-with-bad-characters",
+      "!@#Surrounding bad characters!@#"    => "surrounding-bad-characters",
+      "Squeeze   separators"                => "squeeze-separators",
+      "Test with + sign"                    => "test-with-sign",
+      "Test with a Namespaced::Class"       => "test-with-a-namespaced-class"
+    }
+
+    titles.each do |title, anchor|
+      assert_match %("##{anchor}"), render("# #{title}")
+    end
+  end
+
+  def test_inline_markup_is_not_escaped
+    output = render(@markdown)
+
+    assert_match "A <strong>nice</strong> subtitle", output
+    assert_no_match %r{&lt;}, output
+  end
+
+  def test_inline_markup_escaping
+    output = render(@markdown, with: [:escape_html])
+
+    assert_match "&lt;strong&gt;", output
+    assert_no_match %r{<strong>}, output
+  end
+
+  def test_ignoring_fenced_code_blocks_comments
+    markdown = <<-Markdown.strip_heredoc
+    # Hello world !
+
+    ~~~ruby
+    # This is a comment
+    ~~~
+    Markdown
+
+    output = render(markdown)
+
+    assert output.match("Hello world")
+    refute output.match("This is a comment")
+  end
 end

data/test/markdown_test.rb

@@ -2,339 +2,415 @@
 require 'test_helper'
 
 class MarkdownTest < Greenmat::TestCase
-
   def setup
-    @markdown = Greenmat::Markdown.new(Greenmat::Render::HTML, greenmat_options)
-  end
-
-  def render_with(flags, text)
-    flags = greenmat_options.merge(flags)
-    Greenmat::Markdown.new(Greenmat::Render::HTML, flags).render(text)
-  end
-
-  def greenmat_options
-    { no_mention_emphasis: true }
+    @renderer = Greenmat::Render::HTML
   end
 
   def test_that_simple_one_liner_goes_to_html
-    assert_respond_to @markdown, :render
-    html_equal "<p>Hello World.</p>\n", @markdown.render("Hello World.")
+    assert_equal "<p>Hello World.</p>", render("Hello World.")
   end
 
   def test_that_inline_markdown_goes_to_html
-    markdown = @markdown.render('_Hello World_!')
-    html_equal "<p><em>Hello World</em>!</p>\n", markdown
+    assert_equal "<p><em>Hello World</em>!</p>", render('_Hello World_!')
   end
 
   def test_that_inline_markdown_starts_and_ends_correctly
-    markdown = render_with({:no_intra_emphasis => true}, '_start _ foo_bar bar_baz _ end_ *italic* **bold** <a>_blah_</a>')
+    output   = render('_start _ foo_bar bar_baz _ end_ *italic* **bold** <a>_blah_</a>', with: [:no_intra_emphasis])
+    expected = "<p><em>start _ foo_bar bar_baz _ end</em> <em>italic</em> <strong>bold</strong> <a><em>blah</em></a></p>"
 
-    html_equal "<p><em>start _ foo_bar bar_baz _ end</em> <em>italic</em> <strong>bold</strong> <a><em>blah</em></a></p>\n", markdown
+    assert_equal expected, output
 
-    markdown = @markdown.render("Run 'rake radiant:extensions:rbac_base:migrate'")
-    html_equal "<p>Run 'rake radiant:extensions:rbac_base:migrate'</p>\n", markdown
+    output   = render("Run 'rake radiant:extensions:rbac_base:migrate'")
+    expected = "<p>Run &#39;rake radiant:extensions:rbac_base:migrate&#39;</p>"
+
+    assert_equal expected, output
   end
 
   def test_that_urls_are_not_doubly_escaped
-    markdown = @markdown.render('[Page 2](/search?query=Markdown+Test&page=2)')
-    html_equal "<p><a href=\"/search?query=Markdown+Test&amp;page=2\">Page 2</a></p>\n", markdown
+    output = render('[Page 2](/search?query=Markdown+Test&page=2)')
+    assert_equal "<p><a href=\"/search?query=Markdown+Test&page=2\">Page 2</a></p>", output
   end
 
   def test_simple_inline_html
-    #markdown = Markdown.new("before\n\n<div>\n  foo\n</div>\nafter")
-    markdown = @markdown.render("before\n\n<div>\n  foo\n</div>\n\nafter")
-    html_equal "<p>before</p>\n\n<div>\n  foo\n</div>\n\n<p>after</p>\n", markdown
+    output   = render("before\n\n<div>\n  foo\n</div>\n\nafter")
+    expected = "<p>before</p>\n\n<div>\n  foo\n</div>\n\n<p>after</p>"
+
+    assert_equal expected, output
   end
 
   def test_that_html_blocks_do_not_require_their_own_end_tag_line
-    markdown = @markdown.render("Para 1\n\n<div><pre>HTML block\n</pre></div>\n\nPara 2 [Link](#anchor)")
-    html_equal "<p>Para 1</p>\n\n<div><pre>HTML block\n</pre></div>\n\n<p>Para 2 <a href=\"#anchor\">Link</a></p>\n",
-      markdown
+    output   = render("Para 1\n\n<div><pre>HTML block\n</pre></div>\n\nPara 2 [Link](#anchor)")
+    expected = "<p>Para 1</p>\n\n<div><pre>HTML block\n</pre></div>\n\n<p>Para 2 <a href=\"#anchor\">Link</a></p>"
+
+    assert_equal expected, output
   end
 
   # This isn't in the spec but is Markdown.pl behavior.
   def test_block_quotes_preceded_by_spaces
-    markdown = @markdown.render(
-      "A wise man once said:\n\n" +
-      " > Isn't it wonderful just to be alive.\n"
-    )
-    html_equal "<p>A wise man once said:</p>\n\n" +
-      "<blockquote><p>Isn't it wonderful just to be alive.</p>\n</blockquote>\n",
-      markdown
+    output = render <<-Markdown.strip_heredoc
+      A wise man once said:
+
+
+       > Isn't it wonderful just to be alive.
+    Markdown
+    expected = <<-HTML.chomp.strip_heredoc
+      <p>A wise man once said:</p>
+
+      <blockquote>
+      <p>Isn&#39;t it wonderful just to be alive.</p>
+      </blockquote>
+    HTML
+
+    assert_equal expected, output
   end
 
   def test_para_before_block_html_should_not_wrap_in_p_tag
-    markdown = render_with({:lax_spacing => true},
-      "Things to watch out for\n" +
-      "<ul>\n<li>Blah</li>\n</ul>\n")
+    output   = render("Things to watch out for\n<ul>\n<li>Blah</li>\n</ul>", with: [:lax_spacing])
+    expected = "<p>Things to watch out for</p>\n\n<ul>\n<li>Blah</li>\n</ul>"
 
-    html_equal "<p>Things to watch out for</p>\n\n" +
-      "<ul>\n<li>Blah</li>\n</ul>\n", markdown
+    assert_equal expected, output
   end
 
   # https://github.com/vmg/greenmat/issues/111
   def test_p_with_less_than_4space_indent_should_not_be_part_of_last_list_item
-    text = <<MARKDOWN
+    text = <<-Markdown
   * a
   * b
   * c
 
   This paragraph is not part of the list.
-MARKDOWN
-    expected = <<HTML
-<ul>
-<li>a</li>
-<li>b</li>
-<li>c</li>
-</ul>
+    Markdown
+    expected = <<-HTML.chomp.strip_heredoc
+      <ul>
+      <li>a</li>
+      <li>b</li>
+      <li>c</li>
+      </ul>
 
-<p>This paragraph is not part of the list.</p>
-HTML
-    html_equal expected, @markdown.render(text)
+      <p>This paragraph is not part of the list.</p>
+    HTML
+
+    assert_equal expected, render(text)
   end
 
   # http://github.com/rtomayko/rdiscount/issues/#issue/13
   def test_headings_with_trailing_space
-    text = "The Ant-Sugar Tales \n"         +
-           "=================== \n\n"        +
+    text = "The Ant-Sugar Tales \n"       +
+           "=================== \n\n"     +
            "By Candice Yellowflower   \n"
-    html_equal "<h1>The Ant-Sugar Tales </h1>\n\n<p>By Candice Yellowflower   </p>\n", @markdown.render(text)
+
+    assert_equal "<h1>The Ant-Sugar Tales </h1>\n\n<p>By Candice Yellowflower   </p>", render(text)
   end
 
   def test_that_intra_emphasis_works
-    rd = render_with({}, "foo_bar_baz")
-    html_equal "<p>foo<em>bar</em>baz</p>\n", rd
-
-    rd = render_with({:no_intra_emphasis => true},"foo_bar_baz")
-    html_equal "<p>foo_bar_baz</p>\n", rd
+    assert_equal "<p>foo<em>bar</em>baz</p>", render("foo_bar_baz")
+    assert_equal "<p>foo_bar_baz</p>", render("foo_bar_baz", with: [:no_intra_emphasis])
   end
 
   def test_that_autolink_flag_works
-    rd = render_with({:autolink => true}, "http://github.com/rtomayko/rdiscount")
-    html_equal "<p><a href=\"http://github.com/rtomayko/rdiscount\">http://github.com/rtomayko/rdiscount</a></p>\n", rd
+    output   = render("http://github.com/rtomayko/rdiscount", with: [:autolink])
+    expected = "<p><a href=\"http://github.com/rtomayko/rdiscount\">http://github.com/rtomayko/rdiscount</a></p>"
+
+    assert_equal expected, output
   end
 
   def test_that_tags_can_have_dashes_and_underscores
-    rd = @markdown.render("foo <asdf-qwerty>bar</asdf-qwerty> and <a_b>baz</a_b>")
-    html_equal "<p>foo <asdf-qwerty>bar</asdf-qwerty> and <a_b>baz</a_b></p>\n", rd
-  end
+    output   = render("foo <asdf-qwerty>bar</asdf-qwerty> and <a_b>baz</a_b>")
+    expected = "<p>foo <asdf-qwerty>bar</asdf-qwerty> and <a_b>baz</a_b></p>"
 
-  def test_link_syntax_is_not_processed_within_code_blocks
-    markdown = @markdown.render("    This is a code block\n    This is a link [[1]] inside\n")
-    html_equal "<pre><code>This is a code block\nThis is a link [[1]] inside\n</code></pre>\n",
-      markdown
+    assert_equal expected, output
   end
 
-  def test_whitespace_after_urls
-    rd = render_with({:autolink => true}, "Japan: http://www.abc.net.au/news/events/japan-quake-2011/beforeafter.htm (yes, japan)")
-    exp = %{<p>Japan: <a href="http://www.abc.net.au/news/events/japan-quake-2011/beforeafter.htm">http://www.abc.net.au/news/events/japan-quake-2011/beforeafter.htm</a> (yes, japan)</p>\n}
-    html_equal exp, rd
-  end
+  def test_link_syntax_is_not_processed_within_code_blocks
+    output   = render("    This is a code block\n    This is a link [[1]] inside\n")
+    expected = "<pre><code>This is a code block\nThis is a link [[1]] inside\n</code></pre>"
 
-  def test_auto_linked_www_utf8_issue
-		rd = render_with({ autolink: true }, "www.example.com/码")
-		exp = %{<p><a href="http://www.example.com/%E7%A0%81">www.example.com/码</a></p>\n}
-    assert_equal exp, rd
+    assert_equal expected, output
   end
 
-  def test_auto_linked_url_utf8_issue
-		rd = render_with({ autolink: true }, "http://example.com/码")
-    exp = %{<p><a href="http://example.com/%E7%A0%81">http://example.com/码</a></p>\n}
-    assert_equal exp, rd
-  end
+  def test_whitespace_after_urls
+    output   = render("Japan: http://www.abc.net.au/news/events/japan-quake-2011/beforeafter.htm (yes, japan)", with: [:autolink])
+    expected = %(<p>Japan: <a href="http://www.abc.net.au/news/events/japan-quake-2011/beforeafter.htm">http://www.abc.net.au/news/events/japan-quake-2011/beforeafter.htm</a> (yes, japan)</p>)
 
-  def test_auto_linked_email_utf8_issue
-    rd = render_with({ autolink: true }, "r@example.comあ")
-    exp = %{<p><a href="mailto:r@example.com">r@example.com</a>あ</p>\n}
-    assert_equal exp, rd
+    assert_equal expected, output
   end
 
   def test_memory_leak_when_parsing_char_links
-    @markdown.render(<<-leaks)
-2. Identify the wild-type cluster and determine all clusters
-   containing or contained by it:
+    render(<<-leaks.strip_heredoc)
+      2. Identify the wild-type cluster and determine all clusters
+         containing or contained by it:
 
-       wildtype <- wildtype.cluster(h)
-       wildtype.mask <- logical(nclust)
-       wildtype.mask[c(contains(h, wildtype),
-                       wildtype,
-                       contained.by(h, wildtype))] <- TRUE
+             wildtype <- wildtype.cluster(h)
+             wildtype.mask <- logical(nclust)
+             wildtype.mask[c(contains(h, wildtype),
+                             wildtype,
+                             contained.by(h, wildtype))] <- TRUE
 
-   This could be more elegant.
+         This could be more elegant.
     leaks
   end
 
   def test_infinite_loop_in_header
-    html_equal "<h1>Body</h1>\n", @markdown.render(<<-header)
-######
-#Body#
-######
+    assert_equal "<h1>Body</h1>", render(<<-header.strip_heredoc)
+      ######
+      #Body#
+      ######
     header
   end
 
   def test_a_hyphen_and_a_equal_should_not_be_converted_to_heading
-    html_equal "<p>-</p>\n", @markdown.render("-")
-    html_equal "<p>=</p>\n", @markdown.render("=")
+    assert_equal "<p>-</p>", render("-")
+    assert_equal "<p>=</p>", render("=")
   end
 
   def test_that_tables_flag_works
-    text = <<EOS
- aaa | bbbb
------|------
-hello|sailor
-EOS
+    text = <<-Markdown.strip_heredoc
+       aaa | bbbb
+      -----|------
+      hello|sailor
+    Markdown
 
-    assert render_with({}, text) !~ /<table/
-
-    assert render_with({:tables => true}, text) =~ /<table/
+    assert render(text) !~ /<table/
+    assert render(text, with: [:tables]) =~ /<table/
   end
 
   def test_that_tables_work_with_org_table_syntax
-    text = <<EOS
-| aaa | bbbb |
-|-----+------|
-|hello|sailor|
-EOS
-
-    assert render_with({}, text) !~ /<table/
+    text = <<-Markdown.strip_heredoc
+      | aaa | bbbb |
+      |-----+------|
+      |hello|sailor|
+    Markdown
 
-    assert render_with({:tables => true}, text) =~ /<table/
+    assert render(text) !~ /<table/
+    assert render(text, with: [:tables]) =~ /<table/
   end
 
   def test_strikethrough_flag_works
     text = "this is ~some~ striked ~~text~~"
 
-    assert render_with({}, text) !~ /<del/
-
-    assert render_with({:strikethrough => true}, text) =~ /<del/
+    assert render(text) !~ /<del/
+    assert render(text, with: [:strikethrough]) =~ /<del/
   end
 
   def test_underline_flag_works
-    text = "this is *some* text that is _underlined_. ___boom___"
+    text   = "this is *some* text that is _underlined_. ___boom___"
+    output = render(text, with: [:underline])
 
-    refute render_with({}, text).include? '<u>underlined</u>'
+    refute render(text).include? '<u>underlined</u>'
 
-    output = render_with({:underline => true}, text)
     assert output.include? '<u>underlined</u>'
     assert output.include? '<em>some</em>'
   end
 
   def test_highlight_flag_works
-    text = "this is ==highlighted=="
+    text   = "this is ==highlighted=="
+    output = render(text, with: [:highlight])
 
-    refute render_with({}, text).include? '<mark>highlighted</mark>'
+    refute render(text).include? '<mark>highlighted</mark>'
 
-    output = render_with({:highlight => true}, text)
     assert output.include? '<mark>highlighted</mark>'
   end
 
   def test_quote_flag_works
-    text = 'this is "quote"'
+    text   = 'this is a "quote"'
+    output = render(text, with: [:quote])
 
-    refute render_with({}, text).include? '<q>quote</q>'
+    refute render(text).include? '<q>quote</q>'
 
-    output = render_with({:quote => true}, text)
-    assert output.include? '<q>quote</q>'
+    assert_equal '<p>this is a <q>quote</q></p>', output
   end
 
-  def test_that_fenced_flag_works
-    text = <<fenced
-This is a simple test
+  def test_quote_flag_honors_escape_html
+    text = 'We are not "<svg/onload=pwned>"'
 
-~~~~~
-This is some awesome code
-    with tabs and shit
-~~~
-fenced
+    output_enabled  = render(text, with: [:quote, :escape_html])
+    output_disabled = render(text, with: [:quote])
 
-    assert render_with({}, text) !~ /<code/
+    assert_equal "<p>We are not <q>&lt;svg/onload=pwned&gt;</q></p>", output_enabled
+    assert_equal "<p>We are not <q><svg/onload=pwned></q></p>", output_disabled
+  end
+
+  def test_that_fenced_flag_works
+    text = <<-fenced.strip_heredoc
+      This is a simple test
+
+      ~~~~~
+      This is some awesome code
+          with tabs and shit
+      ~~~
+    fenced
 
-    assert render_with({:fenced_code_blocks => true}, text) =~ /<code/
+    assert render(text) !~ /<code/
+    assert render(text, with: [:fenced_code_blocks]) =~ /<code/
   end
 
   def test_that_fenced_flag_works_without_space
-    text = "foo\nbar\n```\nsome\ncode\n```\nbaz"
-    out = Greenmat::Markdown.new(Greenmat::Render::HTML, :fenced_code_blocks => true, :lax_spacing => true).render(text)
-    assert out.include?("<pre><code>")
+    text   = "foo\nbar\n```\nsome\ncode\n```\nbaz"
+    output = render(text, with: [:fenced_code_blocks, :lax_spacing])
 
-    out = Greenmat::Markdown.new(Greenmat::Render::HTML, :fenced_code_blocks => true).render(text)
-    assert !out.include?("<pre><code>")
+    assert output.include?("<pre><code>")
+
+    output = render(text, with: [:fenced_code_blocks])
+    assert !output.include?("<pre><code>")
   end
 
-  def test_that_fenced_flag_works_with_utf8
-    text = "```ム\ncode\n```"
-    out = Greenmat::Markdown.new(Greenmat::Render::HTML, :fenced_code_blocks => true).render(text)
-    assert out.include?(%{<pre><code class="ム">})
+  def test_that_indented_code_preserves_references
+    text = <<-indented.strip_heredoc
+      This is normal text
+
+          Link to [Google][1]
+
+          [1]: http://google.com
+    indented
+
+    output = render(text, with: [:fenced_code_blocks])
+    assert output.include?("[1]: http://google.com")
+  end
+
+  def test_that_fenced_flag_preserves_references
+    text = <<-fenced.strip_heredoc
+      This is normal text
+
+      ```
+      Link to [Google][1]
+
+      [1]: http://google.com
+      ```
+    fenced
+
+    out = render(text, with: [:fenced_code_blocks])
+    assert out.include?("[1]: http://google.com")
+  end
+
+  def test_that_fenced_code_copies_language_verbatim_with_braces
+    text = "```{rust,no_run}\nx = 'foo'\n```"
+    html = render(text, with: [:fenced_code_blocks])
+
+    assert_equal "<pre><code data-metadata=\"rust,no_run\">x = &#39;foo&#39;\n</code></pre>", html
+  end
+
+  def test_that_fenced_code_copies_language_verbatim
+    text = "```rust,no_run\nx = 'foo'\n```"
+    html = render(text, with: [:fenced_code_blocks])
+
+    assert_equal "<pre><code data-metadata=\"rust,no_run\">x = &#39;foo&#39;\n</code></pre>", html
   end
 
   def test_that_indented_flag_works
-    text = <<indented
-This is a simple text
+    text = <<-indented.strip_heredoc
+      This is a simple text
 
-    This is some awesome code
-    with shit
+          This is some awesome code
+          with shit
 
-And this is again a simple text
-indented
+      And this is again a simple text
+    indented
 
-    assert render_with({}, text) =~ /<code/
-    assert render_with({:disable_indented_code_blocks => true}, text) !~ /<code/
+    assert render(text) =~ /<code/
+    assert render(text, with: [:disable_indented_code_blocks]) !~ /<code/
   end
 
   def test_that_headers_are_linkable
-    markdown = @markdown.render('### Hello [GitHub](http://github.com)')
-    html_equal "<h3>Hello <a href=\"http://github.com\">GitHub</a></h3>\n", markdown
+    output   = render('### Hello [GitHub](http://github.com)')
+    expected = "<h3>Hello <a href=\"http://github.com\">GitHub</a></h3>"
+
+    assert_equal expected, output
   end
 
   def test_autolinking_with_ent_chars
-    markdown = render_with({:autolink => true}, <<text)
-This a stupid link: https://github.com/rtomayko/tilt/issues?milestone=1&state=open
-text
-    html_equal "<p>This a stupid link: <a href=\"https://github.com/rtomayko/tilt/issues?milestone=1&state=open\">https://github.com/rtomayko/tilt/issues?milestone=1&amp;state=open</a></p>\n", markdown
+    markdown = <<-Markdown.strip_heredoc
+      This a stupid link: https://github.com/rtomayko/tilt/issues?milestone=1&state=open
+    Markdown
+    output   = render(markdown, with: [:autolink])
+
+    assert_equal "<p>This a stupid link: <a href=\"https://github.com/rtomayko/tilt/issues?milestone=1&state=open\">https://github.com/rtomayko/tilt/issues?milestone=1&amp;state=open</a></p>", output
   end
 
   def test_spaced_headers
-    rd = render_with({:space_after_headers => true}, "#123 a header yes\n")
-    assert rd !~ /<h1>/
+    output = render("#123 a header yes\n", with: [:space_after_headers])
+
+    assert output !~ /<h1>/
   end
 
   def test_proper_intra_emphasis
-    assert render_with({:no_intra_emphasis => true}, "http://en.wikipedia.org/wiki/Dave_Allen_(comedian)") !~ /<em>/
-    assert render_with({:no_intra_emphasis => true}, "this fails: hello_world_") !~ /<em>/
-    assert render_with({:no_intra_emphasis => true}, "this also fails: hello_world_#bye") !~ /<em>/
-    assert render_with({:no_intra_emphasis => true}, "this works: hello_my_world") !~ /<em>/
-    assert render_with({:no_intra_emphasis => true}, "句中**粗體**測試") =~ /<strong>/
+    assert render("http://en.wikipedia.org/wiki/Dave_Allen_(comedian)", with: [:no_intra_emphasis]) !~ /<em>/
+    assert render("this fails: hello_world_", with: [:no_intra_emphasis]) !~ /<em>/
+    assert render("this also fails: hello_world_#bye", with: [:no_intra_emphasis]) !~ /<em>/
+    assert render("this works: hello_my_world", with: [:no_intra_emphasis]) !~ /<em>/
+    assert render("句中**粗體**測試", with: [:no_intra_emphasis]) =~ /<strong>/
 
     markdown = "This is (**bold**) and this_is_not_italic!"
-    html = "<p>This is (<strong>bold</strong>) and this_is_not_italic!</p>\n"
-    assert_equal html, render_with({:no_intra_emphasis => true}, markdown)
+    output   = "<p>This is (<strong>bold</strong>) and this_is_not_italic!</p>"
+
+    assert_equal output, render(markdown, with: [:no_intra_emphasis])
 
     markdown = "This is \"**bold**\""
-    html = "<p>This is &quot;<strong>bold</strong>&quot;</p>\n"
-    assert_equal html, render_with({:no_intra_emphasis => true}, markdown)
+    output   = "<p>This is &quot;<strong>bold</strong>&quot;</p>"
+    assert_equal output, render(markdown, with: [:no_intra_emphasis])
   end
 
   def test_emphasis_escaping
-    markdown = @markdown.render("**foo\\*** _dd\\_dd_")
-    html_equal "<p><strong>foo*</strong> <em>dd_dd</em></p>\n", markdown
+    assert_equal "<p><strong>foo*</strong> <em>dd_dd</em></p>", render("**foo\\*** _dd\\_dd_")
   end
 
   def test_char_escaping_when_highlighting
-    markdown = "==attribute\\==="
-    output = render_with({highlight: true}, markdown)
-    html_equal "<p><mark>attribute=</mark></p>\n", output
+    output = render("==attribute\\===", with: [:highlight])
+
+    assert_equal "<p><mark>attribute=</mark></p>", output
   end
 
   def test_ordered_lists_with_lax_spacing
-    markdown = "Foo:\n1. Foo\n2. Bar"
-    output = render_with({lax_spacing: true}, markdown)
+    output = render("Foo:\n1. Foo\n2. Bar", with: [:lax_spacing])
 
     assert_match /<ol>/, output
     assert_match /<li>Foo<\/li>/, output
   end
 
   def test_references_with_tabs_after_colon
-    markdown = @markdown.render("[Link][id]\n[id]:\t\t\thttp://google.es")
-    html_equal "<p><a href=\"http://google.es\">Link</a></p>\n", markdown
+    output = render("[Link][id]\n[id]:\t\t\thttp://google.es")
+
+    assert_equal "<p><a href=\"http://google.es\">Link</a></p>", output
+  end
+
+  def test_superscript
+    output = render("this is the 2^nd time", with: [:superscript])
+
+    assert_equal "<p>this is the 2<sup>nd</sup> time</p>", output
+  end
+
+  def test_superscript_enclosed_in_parenthesis
+    output = render("this is the 2^(nd) time", with: [:superscript])
+
+    assert_equal "<p>this is the 2<sup>nd</sup> time</p>", output
+  end
+
+  def test_no_rewind_into_previous_inline
+    result = "<p><em>!dl</em><a href=\"mailto:1@danlec.com\">1@danlec.com</a></p>"
+    output = render("_!dl_1@danlec.com", with: [:autolink])
+
+    assert_equal result, output
+
+    result = "<p>abc123<em><a href=\"http://www.foo.com\">www.foo.com</a></em>@foo.com</p>"
+    output = render("abc123_www.foo.com_@foo.com", with: [:autolink])
+
+    assert_equal result, output
+  end
+
+  def test_autolink_with_period_next_to_url
+    result = %(<p>Checkout a cool site like <a href="https://github.com">https://github.com</a>.</p>)
+    output = render("Checkout a cool site like https://github.com.", with: [:autolink])
+
+    assert_equal result, output
+  end
+
+  def test_single_dashes_on_table_headers
+    markdown = <<-Markdown.strip_heredoc
+      | a | b |
+      | - | - |
+      | c | d |
+    Markdown
+    output   = render(markdown, with: [:tables])
+
+    assert_match /<table>/, output
   end
 end