redcarpet 1.17.2 → 2.0.0

data/test/redcarpet_test.rb

@@ -1,139 +1,212 @@
-# encoding: utf-8
+# coding: UTF-8
 rootdir = File.dirname(File.dirname(__FILE__))
 $LOAD_PATH.unshift "#{rootdir}/lib"
 
+if defined? Encoding
+  Encoding.default_internal = 'UTF-8'
+end
+
 require 'test/unit'
 require 'redcarpet'
+require 'redcarpet/render_man'
+require 'nokogiri'
 
-class RedcarpetTest < Test::Unit::TestCase
-  def test_that_discount_does_not_blow_up_with_weird_formatting_case
-    text = (<<-TEXT).gsub(/^ {4}/, '').rstrip
-    1. some text
+def html_equal(html_a, html_b)
+  assert_equal Nokogiri::HTML::DocumentFragment.parse(html_a).to_html,
+    Nokogiri::HTML::DocumentFragment.parse(html_b).to_html
+end
 
-    1.
-    TEXT
-    Redcarpet.new(text).to_html
+class SmartyPantsTest < Test::Unit::TestCase
+  def setup
+    @pants = Redcarpet::Render::SmartyPants
   end
 
-  def test_that_smart_converts_double_quotes_to_curly_quotes
-    rd = Redcarpet.new(%("Quoted text"), :smart)
-    assert_equal %(<p>&ldquo;Quoted text&rdquo;</p>\n), rd.to_html
+  def test_that_smart_converts_single_quotes_in_words_that_end_in_re
+    markdown = @pants.render("<p>They're not for sale.</p>")
+    assert_equal "<p>They&rsquo;re not for sale.</p>", markdown
   end
 
-  def test_that_smart_converts_double_quotes_to_curly_quotes_before_a_heading
-    rd = Redcarpet.new(%("Quoted text"\n\n# Heading), :smart)
-    assert_equal %(<p>&ldquo;Quoted text&rdquo;</p>\n\n<h1>Heading</h1>\n), rd.to_html
+  def test_that_smart_converts_single_quotes_in_words_that_end_in_ll
+    markdown = @pants.render("<p>Well that'll be the day</p>")
+    assert_equal "<p>Well that&rsquo;ll be the day</p>", markdown
   end
 
-  def test_that_smart_converts_double_quotes_to_curly_quotes_after_a_heading
-    rd = Redcarpet.new(%(# Heading\n\n"Quoted text"), :smart)
-    assert_equal %(<h1>Heading</h1>\n\n<p>&ldquo;Quoted text&rdquo;</p>\n), rd.to_html
+  def test_that_smart_converts_double_quotes_to_curly_quotes
+    rd = @pants.render(%(<p>"Quoted text"</p>))
+    assert_equal %(<p>&ldquo;Quoted text&rdquo;</p>), rd
   end
 
   def test_that_smart_gives_ve_suffix_a_rsquo
-    rd = Redcarpet.new("I've been meaning to tell you ..", :smart)
-    assert_equal "<p>I&rsquo;ve been meaning to tell you ..</p>\n", rd.to_html
+    rd = @pants.render("<p>I've been meaning to tell you ..</p>")
+    assert_equal "<p>I&rsquo;ve been meaning to tell you ..</p>", rd
   end
 
   def test_that_smart_gives_m_suffix_a_rsquo
-    rd = Redcarpet.new("I'm not kidding", :smart)
-    assert_equal "<p>I&rsquo;m not kidding</p>\n", rd.to_html
+    rd = @pants.render("<p>I'm not kidding</p>")
+    assert_equal "<p>I&rsquo;m not kidding</p>", rd
   end
 
   def test_that_smart_gives_d_suffix_a_rsquo
-    rd = Redcarpet.new("what'd you say?", :smart)
-    assert_equal "<p>what&rsquo;d you say?</p>\n", rd.to_html
+    rd = @pants.render("<p>what'd you say?</p>")
+    assert_equal "<p>what&rsquo;d you say?</p>", rd
   end
+end
 
-  if "".respond_to?(:encoding)
-    def test_should_return_string_in_same_encoding_as_input
-      input = "Yogācāra"
-      output = Redcarpet.new(input).to_html
-      assert_equal input.encoding.name, output.encoding.name
-    end
+class HTMLRenderTest < Test::Unit::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),
+    }
+  end
+
+  def render_with(rndr, text)
+    Redcarpet::Markdown.new(rndr).render(text)
+  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>", 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 = Redcarpet.new(%(![dust mite](http://dust.mite/image.png) <img src="image.png" />), :no_image)
-    assert rd.to_html !~ /<img/
+    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 = Redcarpet.new(%([This link](http://example.net/) <a href="links.html">links</a>), :no_links)
-    assert rd.to_html !~ /<a /
+    rd = render_with(@rndr[:no_links], %([This link](http://example.net/) <a href="links.html">links</a>))
+    assert rd !~ /<a /
   end
 
-  def test_that_strict_flag_works
-    rd = RedcarpetCompat.new("foo_bar_baz", :strict)
-    assert_equal "<p>foo<em>bar</em>baz</p>\n", rd.to_html
+  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
+end
 
-  def test_that_autolink_flag_works
-    rd = Redcarpet.new("http://github.com/rtomayko/rdiscount", :autolink)
-    assert_equal "<p><a href=\"http://github.com/rtomayko/rdiscount\">http://github.com/rtomayko/rdiscount</a></p>\n", rd.to_html
+class MarkdownTest < Test::Unit::TestCase
+
+  def setup
+    @markdown = Redcarpet::Markdown.new(Redcarpet::Render::HTML)
   end
 
-  def test_that_safelink_flag_works
-    rd = Redcarpet.new("[IRC](irc://chat.freenode.org/#freenode)", :safelink)
-    assert_equal "<p>[IRC](irc://chat.freenode.org/#freenode)</p>\n", rd.to_html
+  def render_with(flags, text)
+    Redcarpet::Markdown.new(Redcarpet::Render::HTML, flags).render(text)
   end
 
-  def test_that_tags_can_have_dashes_and_underscores
-    rd = Redcarpet.new("foo <asdf-qwerty>bar</asdf-qwerty> and <a_b>baz</a_b>")
-    assert_equal "<p>foo <asdf-qwerty>bar</asdf-qwerty> and <a_b>baz</a_b></p>\n", rd.to_html
+  def test_that_simple_one_liner_goes_to_html
+    assert_respond_to @markdown, :render
+    html_equal "<p>Hello World.</p>", @markdown.render("Hello World.")
   end
-  
-  def xtest_pathological_1
-    star = '*'  * 250000
-    Redcarpet.new("#{star}#{star} hi #{star}#{star}").to_html
+
+  def test_that_inline_markdown_goes_to_html
+    markdown = @markdown.render('_Hello World_!')
+    html_equal "<p><em>Hello World</em>!</p>", markdown
   end
 
-  def xtest_pathological_2
-    crt = '^' * 255
-    str = "#{crt}(\\)"
-    Redcarpet.new("#{str*300}").to_html
+  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>", markdown
+
+    markdown = @markdown.render("Run 'rake radiant:extensions:rbac_base:migrate'")
+    html_equal "<p>Run 'rake radiant:extensions:rbac_base:migrate'</p>", markdown
   end
 
-  def xtest_pathological_3
-    c = "`t`t`t`t`t`t" * 20000000
-    Redcarpet.new(c).to_html
+  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 xtest_pathological_4
-    Redcarpet.new(" [^a]: #{ "A" * 10000 }\n#{ "[^a][]" * 1000000 }\n").to_html.size
+  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_link_syntax_is_not_processed_within_code_blocks
-    markdown = Markdown.new("    This is a code block\n    This is a link [[1]] inside\n")
+  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
 
-    assert_equal "<pre><code>This is a code block\nThis is a link [[1]] inside\n</code></pre>\n",
-      markdown.to_html
+  # 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_that_generate_toc_sets_toc_ids
-    rd = Redcarpet.new("# Level 1\n\n## Level 2", :generate_toc)
-    assert rd.generate_toc
-    assert_equal %(<h1 id="toc_0">Level 1</h1>\n\n<h2 id="toc_1">Level 2</h2>\n), rd.to_html
+  def test_para_before_block_html_should_not_wrap_in_p_tag
+    markdown = render_with({:lax_html_blocks => 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
 
-  def test_should_get_the_generated_toc
-    rd = Redcarpet.new("# Level 1\n\n## Level 2", :generate_toc)
-    exp = %(<ul>\n<li><a href="#toc_0">Level 1</a></li>\n<li><ul>\n<li><a href="#toc_1">Level 2</a></li>\n</ul></li>\n</ul>)
-    assert_equal exp, rd.toc_content.strip
+  # 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 "<h1>The Ant-Sugar Tales </h1>\n\n<p>By Candice Yellowflower   </p>\n", @markdown.render(text)
   end
 
-  def test_whitespace_after_urls
-    rd = Redcarpet.new("Japan: http://www.abc.net.au/news/events/japan-quake-2011/beforeafter.htm (yes, japan)", :autolink)
-    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>}
-    assert_equal exp, rd.to_html.strip
+  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_unbound_recursion
-    Redcarpet.new(("[" * 10000) + "foo" + ("](bar)" * 10000)).to_html
+  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
+
+  if "".respond_to?(:encoding)
+    def test_should_return_string_in_same_encoding_as_input
+      input = "Yogācāra"
+      output = @markdown.render(input)
+      assert_equal input.encoding.name, output.encoding.name
+    end
+  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>}
+    html_equal exp, rd
   end
 
   def test_memory_leak_when_parsing_char_links
-    Redcarpet.new(<<-leaks).to_html
+    @markdown.render(<<-leaks)
 2. Identify the wild-type cluster and determine all clusters
    containing or contained by it:
    
@@ -148,7 +221,7 @@ class RedcarpetTest < Test::Unit::TestCase
   end
 
   def test_infinite_loop_in_header
-    assert_equal Redcarpet.new(<<-header).to_html.strip, "<h1>Body</h1>"
+    html_equal @markdown.render(<<-header), "<h1>Body</h1>"
 ######
 #Body#
 ######
@@ -162,14 +235,17 @@ class RedcarpetTest < Test::Unit::TestCase
 hello|sailor
 EOS
 
-    assert Redcarpet.new(text).to_html !~ /<table/
-    assert Redcarpet.new(text, :tables).to_html =~ /<table/
+    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 Redcarpet.new(text).to_html !~ /<del/
-    assert Redcarpet.new(text, :strikethrough).to_html =~ /<del/
+
+    assert render_with({}, text) !~ /<del/
+
+    assert render_with({:strikethrough => true}, text) =~ /<del/
   end
 
   def test_that_fenced_flag_works
@@ -182,60 +258,71 @@ This is some awesome code
 ~~~
 fenced
 
-    assert Redcarpet.new(text).to_html !~ /<code/
-    assert Redcarpet.new(text, :fenced_code).to_html =~ /<code/
+    assert render_with({}, text) !~ /<code/
+
+    assert render_with({:fenced_code_blocks => true}, text) =~ /<code/
   end
 
-  def test_that_gh_blockcode_works
-    text = <<fenced
-~~~~~ {.python .numbered}
-This is some unsafe code block
-    with custom CSS classes
-~~~~~
-fenced
+  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>", markdown
+  end
 
-    assert Redcarpet.new(text, :fenced_code).to_html =~ /<code class/
-    assert Redcarpet.new(text, :fenced_code, :gh_blockcode).to_html !~ /<code class/
+  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_that_compat_is_working
-    rd = RedcarpetCompat.new(<<EOS)
- aaa | bbbb
------|------
-hello|sailor
+  def test_spaced_headers
+    rd = render_with({:space_after_headers => true}, "#123 a header yes\n")
+    assert rd !~ /<h1>/
+  end
+end
 
-This is ~~striked through~~ test
-EOS
-    assert rd.tables
-    assert rd.to_html =~ /<table/
-    assert rd.to_html =~ /<del/
+class CustomRenderTest < Test::Unit::TestCase
+  class SimpleRender < Redcarpet::Render::HTML
+    def emphasis(text)
+      "<em class=\"cool\">#{text}</em>"
+    end
   end
 
-  def test_that_headers_are_linkable
-    markdown = Redcarpet.new('### Hello [GitHub](http://github.com)')
-    assert_equal "<h3>Hello <a href=\"http://github.com\">GitHub</a></h3>", markdown.to_html.strip
+  def test_simple_overload
+    md = Redcarpet::Markdown.new(SimpleRender)
+    html_equal "<p>This is <em class=\"cool\">just</em> a test</p>",
+      md.render("This is *just* a test")
   end
+end
 
-  def test_autolinking_with_ent_chars
-    markdown = Redcarpet.new(<<text, :autolink)
-This a stupid link: https://github.com/rtomayko/tilt/issues?milestone=1&state=open
-text
-    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>\n", markdown.to_html
+# Disabled by default
+# (these are the easy ones -- the evil ones are not disclosed)
+class PathologicalInputsTest # < Test::Unit::TestCase
+  def setup
+    @markdown = Redcarpet::Markdown.new(Redcarpet::Render::HTML)
   end
 
-  def test_hard_wrap
-    rd = Redcarpet.new(<<text, :hard_wrap)
-This is just a test
-this should have a line break
+  def test_pathological_1
+    star = '*'  * 250000
+    @markdown.render("#{star}#{star} hi #{star}#{star}")
+  end
 
-This is just a test.
-text
-  
-    assert rd.to_html =~ /<br>/
+  def test_pathological_2
+    crt = '^' * 255
+    str = "#{crt}(\\)"
+    @markdown.render("#{str*300}")
   end
 
-  def test_spaced_headers
-    rd = Redcarpet.new("#123 a header yes\n", :space_header)
-    assert rd.to_html !~ /<h1>/
+  def test_pathological_3
+    c = "`t`t`t`t`t`t" * 20000000
+    @markdown.render(c)
+  end
+
+  def test_pathological_4
+    @markdown.render(" [^a]: #{ "A" * 10000 }\n#{ "[^a][]" * 1000000 }\n")
+  end
+
+  def test_unbound_recursion
+    @markdown.render(("[" * 10000) + "foo" + ("](bar)" * 10000))
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: redcarpet
 version: !ruby/object:Gem::Version 
-  hash: 87
+  hash: 15
   prerelease: 
   segments: 
-  - 1
-  - 17
   - 2
-  version: 1.17.2
+  - 0
+  - 0
+  version: 2.0.0
 platform: ruby
 authors: 
 - "Natacha Port\xC3\xA9"
@@ -16,11 +16,23 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-06-19 00:00:00 +02:00
-default_executable: 
-dependencies: []
-
-description: A fast and safe Markdown to (X)HTML parser
+date: 2011-09-14 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rake-compiler
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+description: A fast, safe and extensible Markdown to (X)HTML parser
 email: vicent@github.com
 executables: 
 - redcarpet
@@ -33,27 +45,29 @@ files:
 - README.markdown
 - Rakefile
 - bin/redcarpet
-- ext/redcarpet/array.c
-- ext/redcarpet/array.h
 - ext/redcarpet/autolink.c
 - ext/redcarpet/autolink.h
 - ext/redcarpet/buffer.c
 - ext/redcarpet/buffer.h
 - ext/redcarpet/extconf.rb
+- ext/redcarpet/houdini.h
+- ext/redcarpet/houdini_href_e.c
+- ext/redcarpet/houdini_html_e.c
 - ext/redcarpet/html.c
 - ext/redcarpet/html.h
+- ext/redcarpet/html_blocks.h
 - ext/redcarpet/html_smartypants.c
 - ext/redcarpet/markdown.c
 - ext/redcarpet/markdown.h
-- ext/redcarpet/redcarpet.c
-- lib/markdown.rb
+- ext/redcarpet/rc_markdown.c
+- ext/redcarpet/rc_render.c
+- ext/redcarpet/redcarpet.h
+- ext/redcarpet/stack.c
+- ext/redcarpet/stack.h
 - lib/redcarpet.rb
+- lib/redcarpet/render_man.rb
 - redcarpet.gemspec
-- test/benchmark.rb
-- test/benchmark.txt
-- test/markdown_test.rb
 - test/redcarpet_test.rb
-has_rdoc: true
 homepage: http://github.com/tanoku/redcarpet
 licenses: []
 
@@ -83,10 +97,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.6.2
+rubygems_version: 1.8.6
 signing_key: 
 specification_version: 3
-summary: Ruby bindings for libupskirt
+summary: Markdown that smells nice
 test_files: 
-- test/markdown_test.rb
 - test/redcarpet_test.rb