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

tight-redcarpet 3.1.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

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