tight-redcarpet 3.1.1 → 3.2.0

data/test/html_render_test.rb

@@ -3,21 +3,7 @@ require 'test_helper'
 
 class HTMLRenderTest < Redcarpet::TestCase
   def setup
-    @markdown = Redcarpet::Markdown.new(Redcarpet::Render::HTML)
-    @rndr = {
-      :no_html => Redcarpet::Render::HTML.new(:filter_html => true),
-      :no_images => Redcarpet::Render::HTML.new(:no_images => true),
-      :no_links => Redcarpet::Render::HTML.new(:no_links => true),
-      :safe_links => Redcarpet::Render::HTML.new(:safe_links_only => true),
-      :escape_html => Redcarpet::Render::HTML.new(:escape_html => true),
-      :hard_wrap => Redcarpet::Render::HTML.new(:hard_wrap => true),
-      :toc_data => Redcarpet::Render::HTML.new(:with_toc_data => true),
-      :prettify => Redcarpet::Render::HTML.new(:prettify => true)
-    }
-  end
-
-  def render_with(rndr, text)
-    Redcarpet::Markdown.new(rndr).render(text)
+    @renderer = Redcarpet::Render::HTML
   end
 
   # Hint: overrides filter_html, no_images and no_links
@@ -37,45 +23,55 @@ EOS
 <p>&lt;img src=&quot;/favicon.ico&quot; /&gt;</p>
 EOE
 
-    markdown = render_with(@rndr[:escape_html], source)
-    html_equal expected, markdown
+    html_equal expected, render(source, with: [:escape_html])
   end
 
   def test_that_filter_html_works
-    markdown = render_with(@rndr[:no_html], 'Through <em>NO</em> <script>DOUBLE NO</script>')
-    html_equal "<p>Through NO DOUBLE NO</p>\n", markdown
+    markdown = 'Through <em>NO</em> <script>DOUBLE NO</script>'
+    output   = render(markdown, with: [:filter_html])
+
+    html_equal "<p>Through NO DOUBLE NO</p>\n", output
   end
 
   def test_filter_html_doesnt_break_two_space_hard_break
-    markdown = render_with(@rndr[:no_html], "Lorem,  \nipsum\n")
-    html_equal "<p>Lorem,<br/>\nipsum</p>\n", markdown
+    markdown = "Lorem,  \nipsum\n"
+    output   = render(markdown, with: [:filter_html])
+
+    html_equal "<p>Lorem,<br/>\nipsum</p>\n", output
   end
 
   def test_that_no_image_flag_works
-    rd = render_with(@rndr[:no_images], %(![dust mite](http://dust.mite/image.png) <img src="image.png" />))
-    assert rd !~ /<img/
+    markdown = %(![dust mite](http://dust.mite/image.png) <img src="image.png" />)
+    output   = render(markdown, with: [:no_images])
+
+    assert_no_match %r{<img}, output
   end
 
   def test_that_no_links_flag_works
-    rd = render_with(@rndr[:no_links], %([This link](http://example.net/) <a href="links.html">links</a>))
-    assert rd !~ /<a /
+    markdown = %([This link](http://example.net/) <a href="links.html">links</a>)
+    output   = render(markdown, with: [:no_links])
+
+    assert_no_match %r{<a }, output
   end
 
   def test_that_safelink_flag_works
-    rd = render_with(@rndr[:safe_links], "[IRC](irc://chat.freenode.org/#freenode)")
-    html_equal "<p>[IRC](irc://chat.freenode.org/#freenode)</p>\n", rd
+    markdown = "[IRC](irc://chat.freenode.org/#freenode)"
+    output   = render(markdown, with: [:safe_links_only])
+
+    html_equal "<p>[IRC](irc://chat.freenode.org/#freenode)</p>\n", output
   end
 
   def test_that_hard_wrap_works
-    rd = render_with(@rndr[:hard_wrap], <<EOE)
+    markdown = <<EOE
 Hello world,
 this is just a simple test
 
 With hard wraps
 and other *things*.
 EOE
+    output   = render(markdown, with: [:hard_wrap])
 
-    assert rd =~ /<br>/
+    assert_match %r{<br>}, output
   end
 
   def test_that_link_attributes_work
@@ -85,11 +81,11 @@ EOE
   end
 
   def test_that_link_works_with_quotes
-    rd = render_with(Redcarpet::Render::HTML.new, %([This'link"is](http://example.net/)))
-    assert_equal "<p><a href=\"http://example.net/\">This'link\"is</a></p>\n", rd
+    markdown = %([This'link"is](http://example.net/))
+    expected = %(<p><a href="http://example.net/">This'link"is</a></p>\n)
 
-    rd = render_with(@rndr[:escape_html], %([This'link"is](http://example.net/)))
-    assert_equal "<p><a href=\"http://example.net/\">This'link\"is</a></p>\n", rd
+    assert_equal expected, render(markdown)
+    assert_equal expected, render(markdown, with: [:escape_html])
   end
 
   def test_that_code_emphasis_work
@@ -111,22 +107,19 @@ However, this should be <em><code>an emphasised codespan</code></em></p>
 </ul>
 HTML
 
-    output = render_with(Redcarpet::Render::HTML.new, markdown)
-    assert_equal html, output
+    assert_equal html, render(markdown)
   end
 
   def test_that_parenthesis_are_handled_into_links
-    markdown = "Hey have a look at the [bash man page](man:bash(1))!"
-    html = "<p>Hey have a look at the <a href=\"man:bash(1)\">bash man page</a>!</p>\n"
-    output = render_with(Redcarpet::Render::HTML.new, markdown)
+    markdown = %(The [bash man page](man:bash(1))!)
+    expected = %(<p>The <a href="man:bash(1)">bash man page</a>!</p>\n)
 
-    assert_equal html, output
+    assert_equal expected, render(markdown)
   end
 
   def test_autolinking_works_as_expected
-    markdown = "Example of uri ftp://user:pass@example.com/. Email foo@bar.com and link http://bar.com"
-    renderer = Redcarpet::Markdown.new(Redcarpet::Render::HTML, :autolink => true)
-    output = renderer.render(markdown)
+    markdown = "Uri ftp://user:pass@example.com/. Email foo@bar.com and link http://bar.com"
+    output   = render(markdown, with: [:autolink])
 
     assert output.include? '<a href="ftp://user:pass@example.com/">ftp://user:pass@example.com/</a>'
     assert output.include? 'mailto:foo@bar.com'
@@ -155,8 +148,7 @@ MD
 </div>
 HTML
 
-    renderer = Redcarpet::Markdown.new(Redcarpet::Render::HTML, :footnotes => true)
-    output = renderer.render(markdown)
+    output = render(markdown, with: [:footnotes])
     assert_equal html, output
   end
 
@@ -172,61 +164,78 @@ MD
 <p>[^1] And a trailing definition</p>
 HTML
 
-    renderer = Redcarpet::Markdown.new(Redcarpet::Render::HTML, :footnotes => true)
-    output = renderer.render(markdown)
+    output = render(markdown, with: [:footnotes])
     assert_equal html, output
   end
 
   def test_footnotes_enabled_but_missing_definition
     markdown = "Some text with a marker[^1] but no definition."
-    html = "<p>Some text with a marker[^1] but no definition.</p>\n"
+    expected = "<p>Some text with a marker[^1] but no definition.</p>\n"
 
-    renderer = Redcarpet::Markdown.new(Redcarpet::Render::HTML, :footnotes => true)
-    output = renderer.render(markdown)
-    assert_equal html, output
+    output = render(markdown, with: [:footnotes])
+    assert_equal expected, output
   end
 
   def test_autolink_short_domains
     markdown = "Example of uri ftp://auto/short/domains. Email auto@l.n and link http://a/u/t/o/s/h/o/r/t"
-    renderer = Redcarpet::Markdown.new(Redcarpet::Render::HTML, :autolink => true)
-    output = renderer.render(markdown)
+    output   = render(markdown, with: [:autolink])
 
     assert output.include? '<a href="ftp://auto/short/domains">ftp://auto/short/domains</a>'
     assert output.include? 'mailto:auto@l.n'
     assert output.include? '<a href="http://a/u/t/o/s/h/o/r/t">http://a/u/t/o/s/h/o/r/t</a>'
   end
 
-  def test_toc_heading_id
-    markdown = "# First level  heading\n## Second level heading"
-    output = render_with(@rndr[:toc_data], markdown)
-    assert_match /<h1 id="first-level-heading">/, output
-    assert_match /<h2 id="second-level-heading">/, output
-  end
-
   def test_that_prettify_works
-    text = <<-Markdown
-Foo
+    markdown = "\tclass Foo\nend"
+    output   = render(markdown, with: [:prettify])
+
+    assert output.include?("<pre><code class=\"prettyprint\">")
 
-~~~ruby
-some
-code
-~~~
+    markdown = "`class`"
+    output   = render(markdown, with: [:prettify])
 
-Bar
-Markdown
+    assert output.include?("<code class=\"prettyprint\">")
+  end
 
-    renderer = Redcarpet::Markdown.new(@rndr[:prettify], fenced_code_blocks: true)
-    output = renderer.render(text)
+  def test_prettify_with_fenced_code_blocks
+    markdown = "~~~ruby\ncode\n~~~"
+    output   = render(markdown, with: [:fenced_code_blocks, :prettify])
 
-    assert output.include?("<code class=\"prettyprint ruby\">")
+    assert output.include?("<code class=\"prettyprint lang-ruby\">")
   end
 
   def test_safe_links_only_with_anchors
     markdown = "An [anchor link](#anchor) on a page."
-
-    renderer = Redcarpet::Markdown.new(@rndr[:safe_links])
-    output = renderer.render(markdown)
+    output   = render(markdown, with: [:safe_links_only])
 
     assert_match %r{<a href="#anchor">anchor link</a>}, output
   end
+
+  def test_autolink_with_link_attributes
+    options = { autolink: true, link_attributes: {rel: "nofollow"} }
+    output  = render("https://github.com/", with: options)
+
+    assert_match %r{rel="nofollow"}, output
+  end
+
+  def test_image_unsafe_src_with_safe_links_only
+    markdown = "![foo](javascript:while(1);)"
+    output   = render(markdown, with: [:safe_links_only])
+
+    assert_not_match %r{img src}, output
+  end
+
+  def test_no_styles_option_inside_a_paragraph
+    markdown = "Hello <style> foo { bar: baz; } </style> !"
+    output   = render(markdown, with: [:no_styles])
+
+    assert_no_match %r{<style>}, output
+  end
+
+  def test_no_styles_inside_html_block_rendering
+    markdown = "<style> foo { bar: baz; } </style>"
+    output   = render(markdown, with: [:no_styles])
+
+    assert_no_match %r{<style>}, output
+  end
 end

data/test/html_toc_render_test.rb

@@ -3,13 +3,12 @@ require 'test_helper'
 
 class HTMLTOCRenderTest < Redcarpet::TestCase
   def setup
-    @render = Redcarpet::Render::HTML_TOC
+    @renderer = Redcarpet::Render::HTML_TOC
     @markdown = "# A title \n## A __nice__ subtitle\n## Another one \n### A sub-sub-title"
   end
 
   def test_simple_toc_render
-    renderer = Redcarpet::Markdown.new(@render)
-    output = renderer.render(@markdown).strip
+    output = render(@markdown).strip
 
     assert output.start_with?("<ul>")
     assert output.end_with?("</ul>")
@@ -19,8 +18,7 @@ class HTMLTOCRenderTest < Redcarpet::TestCase
   end
 
   def test_granular_toc_render
-    renderer = Redcarpet::Markdown.new(@render.new(nesting_level: 2))
-    output = renderer.render(@markdown).strip
+    output = render(@markdown, with: { nesting_level: 2 }).strip
 
     assert output.start_with?("<ul>")
     assert output.end_with?("</ul>")
@@ -30,8 +28,7 @@ class HTMLTOCRenderTest < Redcarpet::TestCase
   end
 
   def test_toc_heading_id
-    renderer = Redcarpet::Markdown.new(@render)
-    output = renderer.render(@markdown)
+    output = render(@markdown)
 
     assert_match /a-title/, output
     assert_match /a-nice-subtitle/, output
@@ -40,10 +37,40 @@ class HTMLTOCRenderTest < Redcarpet::TestCase
   end
 
   def test_toc_heading_with_hyphen_and_equal
-    renderer = Redcarpet::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",
+      "Trailing bad characters!@#"          => "trailing-bad-characters",
+      "!@#Leading bad characters"           => "leading-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
 end

data/test/markdown_test.rb

@@ -238,6 +238,32 @@ fenced
     assert !out.include?("<pre><code>")
   end
 
+  def test_that_indented_code_preserves_references
+    text = <<indented
+This is normal text
+
+    Link to [Google][1]
+
+    [1]: http://google.com
+indented
+    out = Redcarpet::Markdown.new(Redcarpet::Render::HTML, :fenced_code_blocks => true).render(text)
+    assert out.include?("[1]: http://google.com")
+  end
+
+  def test_that_fenced_flag_preserves_references
+    text = <<fenced
+This is normal text
+
+```
+Link to [Google][1]
+
+[1]: http://google.com
+```
+fenced
+    out = Redcarpet::Markdown.new(Redcarpet::Render::HTML, :fenced_code_blocks => true).render(text)
+    assert out.include?("[1]: http://google.com")
+  end
+
   def test_that_indented_flag_works
     text = <<indented
 This is a simple text

data/test/safe_render_test.rb

@@ -0,0 +1,36 @@
+require 'test_helper'
+
+class SafeRenderTest < Redcarpet::TestCase
+  def setup
+    @render = Redcarpet::Render::Safe
+    @parser = Redcarpet::Markdown.new(@render, fenced_code_blocks: true)
+  end
+
+  def test_safe_links_only_is_enabled_by_default
+    markdown = "[foo](javascript:alert('foo'))"
+    output   = @parser.render(markdown)
+
+    assert_not_match %r{a href}, output
+  end
+
+  def test_escape_html_is_enabled_by_default
+    markdown = "<p>Hello world!</p>"
+    output   = @parser.render(markdown)
+
+    assert_match %r{&lt;}, output
+  end
+
+  def test_html_escaping_in_code_blocks
+    markdown = "~~~\n<p>Hello!</p>\n~~~"
+    output   = @parser.render(markdown)
+
+    assert_match %r{&lt;p&gt;}, output
+  end
+
+  def test_lang_class_is_removed
+    markdown = "~~~ruby\nclass Foo; end\n~~~"
+    output   = @parser.render(markdown)
+
+    assert_not_match %r{ruby}, output
+  end
+end

data/test/stripdown_render_test.rb

@@ -2,41 +2,39 @@
 require 'test_helper'
 
 class StripDownRender < Redcarpet::TestCase
-
   def setup
-    @markdown = Redcarpet::Markdown.new(Redcarpet::Render::StripDown)
+    @parser = Redcarpet::Markdown.new(Redcarpet::Render::StripDown)
   end
 
-  def test_basics
-    markdown = <<-Markdown
-# [Foo bar](https://github.com)
-Markdown
-    html = @markdown.render(markdown)
-    html_equal "Foo bar\n", html
+  def test_titles
+    markdown = "# Foo bar"
+    output   = @parser.render(markdown)
+
+    assert_equal "Foo bar\n", output
   end
 
-  def test_insert_new_lines_char
-    markdown = <<-Markdown
-# Foo bar
+  def test_code_blocks
+    markdown = "\tclass Foo\n\tend"
+    output   = @parser.render(markdown)
+
+    assert_equal "class Foo\nend\n", output
+  end
 
-Hello world! Please visit [this site](https://github.com/).
+  def test_images
+    markdown = "Look at this ![picture](http://example.org/picture.png)\n" \
+               "And this: ![](http://example.org/image.jpg)"
+    expected = "Look at this picture http://example.org/picture.png\n" \
+               "And this: http://example.org/image.jpg\n"
+    output   = @parser.render(markdown)
 
-    class Foo
-    end
+    assert_equal expected, output
+  end
 
-Look at this ![picture](http://example.org/picture.png)
-And this: ![](http://example.org/image.jpg)
-Markdown
-    plaintext = <<-Plaintext
-Foo bar
-Hello world! Please visit this site.
-class Foo
-end
-Look at this picture http://example.org/picture.png
-And this: http://example.org/image.jpg
-Plaintext
+  def test_links
+    markdown = "Here's an [example](https://github.com)"
+    expected = "Here's an example (https://github.com)\n"
+    output   = @parser.render(markdown)
 
-    html = @markdown.render(markdown)
-    html_equal plaintext, html
+    assert_equal expected, output
   end
 end