RubyGems - tight-redcarpet - Versions diffs - 3.1.1 - Mend

tight-redcarpet 3.1.1

Files changed (41) hide show

checksums.yaml +7 -0
data/COPYING +14 -0
data/Gemfile +9 -0
data/README.markdown +386 -0
data/Rakefile +60 -0
data/bin/redcarpet +43 -0
data/ext/redcarpet/autolink.c +296 -0
data/ext/redcarpet/autolink.h +49 -0
data/ext/redcarpet/buffer.c +196 -0
data/ext/redcarpet/buffer.h +83 -0
data/ext/redcarpet/extconf.rb +6 -0
data/ext/redcarpet/houdini.h +29 -0
data/ext/redcarpet/houdini_href_e.c +108 -0
data/ext/redcarpet/houdini_html_e.c +83 -0
data/ext/redcarpet/html.c +770 -0
data/ext/redcarpet/html.h +78 -0
data/ext/redcarpet/html_blocks.h +206 -0
data/ext/redcarpet/html_smartypants.c +445 -0
data/ext/redcarpet/markdown.c +2907 -0
data/ext/redcarpet/markdown.h +141 -0
data/ext/redcarpet/rc_markdown.c +165 -0
data/ext/redcarpet/rc_render.c +529 -0
data/ext/redcarpet/redcarpet.h +30 -0
data/ext/redcarpet/stack.c +62 -0
data/ext/redcarpet/stack.h +26 -0
data/lib/redcarpet.rb +125 -0
data/lib/redcarpet/compat.rb +3 -0
data/lib/redcarpet/render_man.rb +65 -0
data/lib/redcarpet/render_strip.rb +48 -0
data/redcarpet.gemspec +65 -0
data/test/custom_render_test.rb +28 -0
data/test/html_render_test.rb +232 -0
data/test/html_toc_render_test.rb +49 -0
data/test/markdown_test.rb +311 -0
data/test/pathological_inputs_test.rb +34 -0
data/test/redcarpet_compat_test.rb +38 -0
data/test/smarty_html_test.rb +45 -0
data/test/smarty_pants_test.rb +48 -0
data/test/stripdown_render_test.rb +42 -0
data/test/test_helper.rb +18 -0
metadata +141 -0

data/test/html_render_test.rb ADDED Viewed

@@ -0,0 +1,232 @@
+# coding: UTF-8
+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)
+  end
+  # Hint: overrides filter_html, no_images and no_links
+  def test_that_escape_html_works
+    source = <<EOS
+Through <em>NO</em> <script>DOUBLE NO</script>
+<script>BAD</script>
+<img src="/favicon.ico" />
+EOS
+    expected = <<EOE
+<p>Through &lt;em&gt;NO&lt;/em&gt; &lt;script&gt;DOUBLE NO&lt;/script&gt;</p>
+<p>&lt;script&gt;BAD&lt;/script&gt;</p>
+<p>&lt;img src=&quot;/favicon.ico&quot; /&gt;</p>
+EOE
+    markdown = render_with(@rndr[:escape_html], source)
+    html_equal expected, markdown
+  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
+  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
+  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/
+  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 /
+  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
+  end
+  def test_that_hard_wrap_works
+    rd = render_with(@rndr[:hard_wrap], <<EOE)
+Hello world,
+this is just a simple test
+With hard wraps
+and other *things*.
+EOE
+    assert rd =~ /<br>/
+  end
+  def test_that_link_attributes_work
+    rndr = Redcarpet::Render::HTML.new(:link_attributes => {:rel => 'blank'})
+    md = Redcarpet::Markdown.new(rndr)
+    assert md.render('This is a [simple](http://test.com) test.').include?('rel="blank"')
+  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
+    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
+  end
+  def test_that_code_emphasis_work
+    markdown = <<-MD
+This should be **`a bold codespan`**
+However, this should be *`an emphasised codespan`*
+* **`ABC`** or **`DEF`**
+* Foo bar
+MD
+    html = <<HTML
+<p>This should be <strong><code>a bold codespan</code></strong>
+However, this should be <em><code>an emphasised codespan</code></em></p>
+<ul>
+<li><strong><code>ABC</code></strong> or <strong><code>DEF</code></strong></li>
+<li>Foo bar</li>
+</ul>
+HTML
+    output = render_with(Redcarpet::Render::HTML.new, markdown)
+    assert_equal html, output
+  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)
+    assert_equal html, output
+  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)
+    assert output.include? '<a href="ftp://user:pass@example.com/">ftp://user:pass@example.com/</a>'
+    assert output.include? 'mailto:foo@bar.com'
+    assert output.include? '<a href="http://bar.com">'
+  end
+  def test_that_footnotes_work
+    markdown = <<-MD
+This is a footnote.[^1]
+[^1]: It provides additional information.
+MD
+    html = <<HTML
+<p>This is a footnote.<sup id="fnref1"><a href="#fn1" rel="footnote">1</a></sup></p>
+<div class="footnotes">
+<hr>
+<ol>
+<li id="fn1">
+<p>It provides additional information.&nbsp;<a href="#fnref1" rev="footnote">&#8617;</a></p>
+</li>
+</ol>
+</div>
+HTML
+    renderer = Redcarpet::Markdown.new(Redcarpet::Render::HTML, :footnotes => true)
+    output = renderer.render(markdown)
+    assert_equal html, output
+  end
+  def test_footnotes_enabled_but_missing_marker
+    markdown = <<MD
+Some text without a marker
+[^1] And a trailing definition
+MD
+    html = <<HTML
+<p>Some text without a marker</p>
+<p>[^1] And a trailing definition</p>
+HTML
+    renderer = Redcarpet::Markdown.new(Redcarpet::Render::HTML, :footnotes => true)
+    output = renderer.render(markdown)
+    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"
+    renderer = Redcarpet::Markdown.new(Redcarpet::Render::HTML, :footnotes => true)
+    output = renderer.render(markdown)
+    assert_equal html, 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)
+    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
+~~~ruby
+some
+code
+~~~
+Bar
+Markdown
+    renderer = Redcarpet::Markdown.new(@rndr[:prettify], fenced_code_blocks: true)
+    output = renderer.render(text)
+    assert output.include?("<code class=\"prettyprint 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)
+    assert_match %r{<a href="#anchor">anchor link</a>}, output
+  end
+end

data/test/html_toc_render_test.rb ADDED Viewed

@@ -0,0 +1,49 @@
+# coding: UTF-8
+require 'test_helper'
+class HTMLTOCRenderTest < Redcarpet::TestCase
+  def setup
+    @render = 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
+    assert output.start_with?("<ul>")
+    assert output.end_with?("</ul>")
+    assert_equal 3, output.scan("<ul>").length
+    assert_equal 4, output.scan("<li>").length
+  end
+  def test_granular_toc_render
+    renderer = Redcarpet::Markdown.new(@render.new(nesting_level: 2))
+    output = renderer.render(@markdown).strip
+    assert output.start_with?("<ul>")
+    assert output.end_with?("</ul>")
+    assert_equal 3, output.scan("<li>").length
+    assert !output.include?("A sub-sub title")
+  end
+  def test_toc_heading_id
+    renderer = Redcarpet::Markdown.new(@render)
+    output = renderer.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
+  end
+  def test_toc_heading_with_hyphen_and_equal
+    renderer = Redcarpet::Markdown.new(@render)
+    output = renderer.render("# Hello World\n\n-\n\n=")
+    assert_equal 1, output.scan("<li>").length
+    assert !output.include?('<a href=\"#\"></a>')
+  end
+end

data/test/markdown_test.rb ADDED Viewed

@@ -0,0 +1,311 @@
+# coding: UTF-8
+require 'test_helper'
+class MarkdownTest < Redcarpet::TestCase
+  def setup
+    @markdown = Redcarpet::Markdown.new(Redcarpet::Render::HTML)
+  end
+  def render_with(flags, text)
+    Redcarpet::Markdown.new(Redcarpet::Render::HTML, flags).render(text)
+  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.")
+  end
+  def test_that_inline_markdown_goes_to_html
+    markdown = @markdown.render('_Hello World_!')
+    html_equal "<p><em>Hello World</em>!</p>\n", markdown
+  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>')
+    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
+    markdown = @markdown.render("Run 'rake radiant:extensions:rbac_base:migrate'")
+    html_equal "<p>Run 'rake radiant:extensions:rbac_base:migrate'</p>\n", markdown
+  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
+  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
+  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
+  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
+  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")
+    html_equal "<p>Things to watch out for</p>\n\n" +
+      "<ul>\n<li>Blah</li>\n</ul>\n", markdown
+  end
+  # https://github.com/vmg/redcarpet/issues/111
+  def test_p_with_less_than_4space_indent_should_not_be_part_of_last_list_item
+    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>
+<p>This paragraph is not part of the list.</p>
+HTML
+    html_equal expected, @markdown.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"        +
+           "By Candice Yellowflower   \n"
+    html_equal "<h3>The Ant-Sugar Tales </h3>\n\n<p>By Candice Yellowflower   </p>\n", @markdown.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
+  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
+  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
+  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
+  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_memory_leak_when_parsing_char_links
+    @markdown.render(<<-leaks)
+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
+   This could be more elegant.
+    leaks
+  end
+  def test_infinite_loop_in_header
+    html_equal "<h1>Body</h1>\n", @markdown.render(<<-header)
+######
+#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("=")
+  end
+  def test_that_tables_flag_works
+    text = <<EOS
+ aaa | bbbb
+-----|------
+hello|sailor
+EOS
+    assert render_with({}, text) !~ /<table/
+    assert render_with({:tables => true}, text) =~ /<table/
+  end
+  def test_that_tables_work_with_org_table_syntax
+    text = <<EOS
+| aaa | bbbb |
+|-----+------|
+|hello|sailor|
+EOS
+    assert render_with({}, text) !~ /<table/
+    assert render_with({:tables => true}, text) =~ /<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/
+  end
+  def test_underline_flag_works
+    text = "this is *some* text that is _underlined_. ___boom___"
+    refute render_with({}, 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=="
+    refute render_with({}, 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"'
+    refute render_with({}, text).include? '<q>quote</q>'
+    output = render_with({:quote => true}, text)
+    assert output.include? '<q>quote</q>'
+  end
+  def test_that_fenced_flag_works
+    text = <<fenced
+This is a simple test
+~~~~~
+This is some awesome code
+    with tabs and shit
+~~~
+fenced
+    assert render_with({}, text) !~ /<code/
+    assert render_with({:fenced_code_blocks => true}, text) =~ /<code/
+  end
+  def test_that_fenced_flag_works_without_space
+    text = "foo\nbar\n```\nsome\ncode\n```\nbaz"
+    out = Redcarpet::Markdown.new(Redcarpet::Render::HTML, :fenced_code_blocks => true, :lax_spacing => true).render(text)
+    assert out.include?("<pre><code>")
+    out = Redcarpet::Markdown.new(Redcarpet::Render::HTML, :fenced_code_blocks => true).render(text)
+    assert !out.include?("<pre><code>")
+  end
+  def test_that_indented_flag_works
+    text = <<indented
+This is a simple text
+    This is some awesome code
+    with shit
+And this is again a simple text
+indented
+    assert render_with({}, text) =~ /<code/
+    assert render_with({:disable_indented_code_blocks => true}, text) !~ /<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
+  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
+  end
+  def test_spaced_headers
+    rd = render_with({:space_after_headers => true}, "#123 a header yes\n")
+    assert rd !~ /<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>/
+    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)
+    markdown = "This is \"**bold**\""
+    html = "<p>This is \"<strong>bold</strong>\"</p>\n"
+    assert_equal html, render_with({:no_intra_emphasis => true}, markdown)
+  end
+  def test_emphasis_escaping
+    markdown = @markdown.render("**foo\\*** _dd\\_dd_")
+    html_equal "<p><strong>foo*</strong> <em>dd_dd</em></p>\n", markdown
+  end
+  def test_char_escaping_when_highlighting
+    markdown = "==attribute\\==="
+    output = render_with({highlight: true}, markdown)
+    html_equal "<p><mark>attribute=</mark></p>\n", output
+  end
+  def test_ordered_lists_with_lax_spacing
+    markdown = "Foo:\n1. Foo\n2. Bar"
+    output = render_with({lax_spacing: true}, markdown)
+    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
+  end
+end