redcarpet 2.2.2 → 2.3.0

data/ext/redcarpet/redcarpet.h

@@ -17,7 +17,7 @@
 
 #define CSTR2SYM(s) (ID2SYM(rb_intern((s))))
 
-extern void Init_redcarpet_rndr();
+void Init_redcarpet_rndr();
 
 struct redcarpet_renderopt {
 	struct html_renderopt html;

data/ext/redcarpet/stack.c

@@ -2,7 +2,7 @@
 #include <string.h>
 
 int
-stack_grow(struct stack *st, size_t new_size)
+redcarpet_stack_grow(struct stack *st, size_t new_size)
 {
 	void **new_st;
 
@@ -26,7 +26,7 @@ stack_grow(struct stack *st, size_t new_size)
 }
 
 void
-stack_free(struct stack *st)
+redcarpet_stack_free(struct stack *st)
 {
 	if (!st)
 		return;
@@ -39,7 +39,7 @@ stack_free(struct stack *st)
 }
 
 int
-stack_init(struct stack *st, size_t initial_size)
+redcarpet_stack_init(struct stack *st, size_t initial_size)
 {
 	st->item = NULL;
 	st->size = 0;
@@ -48,11 +48,11 @@ stack_init(struct stack *st, size_t initial_size)
 	if (!initial_size)
 		initial_size = 8;
 
-	return stack_grow(st, initial_size);
+	return redcarpet_stack_grow(st, initial_size);
 }
 
 void *
-stack_pop(struct stack *st)
+redcarpet_stack_pop(struct stack *st)
 {
 	if (!st->size)
 		return NULL;
@@ -61,9 +61,9 @@ stack_pop(struct stack *st)
 }
 
 int
-stack_push(struct stack *st, void *item)
+redcarpet_stack_push(struct stack *st, void *item)
 {
-	if (stack_grow(st, st->size * 2) < 0)
+	if (redcarpet_stack_grow(st, st->size * 2) < 0)
 		return -1;
 
 	st->item[st->size++] = item;
@@ -71,7 +71,7 @@ stack_push(struct stack *st, void *item)
 }
 
 void *
-stack_top(struct stack *st)
+redcarpet_stack_top(struct stack *st)
 {
 	if (!st->size)
 		return NULL;

data/ext/redcarpet/stack.h

@@ -13,14 +13,14 @@ struct stack {
 	size_t asize;
 };
 
-void stack_free(struct stack *);
-int stack_grow(struct stack *, size_t);
-int stack_init(struct stack *, size_t);
+void redcarpet_stack_free(struct stack *);
+int redcarpet_stack_grow(struct stack *, size_t);
+int redcarpet_stack_init(struct stack *, size_t);
 
-int stack_push(struct stack *, void *);
+int redcarpet_stack_push(struct stack *, void *);
 
-void *stack_pop(struct stack *);
-void *stack_top(struct stack *);
+void *redcarpet_stack_pop(struct stack *);
+void *redcarpet_stack_top(struct stack *);
 
 #ifdef __cplusplus
 }

data/lib/redcarpet.rb

@@ -1,7 +1,7 @@
 require 'redcarpet.so'
 
 module Redcarpet
-  VERSION = '2.2.2'
+  VERSION = '2.3.0'
 
   class Markdown
     attr_reader :renderer
@@ -77,6 +77,7 @@ class RedcarpetCompat
     :fenced_code => :fenced_code_blocks,
     :filter_html => :filter_html,
     :hard_wrap => :hard_wrap,
+    :prettify => :prettify,
     :lax_htmlblock => :lax_spacing,
     :no_image => :no_images,
     :no_intraemphasis => :no_intra_emphasis,
@@ -96,7 +97,7 @@ class RedcarpetCompat
   }
   
   RENDERER_OPTIONS = [:filter_html, :no_images, :no_links, :no_styles, 
-    :safe_links_only, :with_toc_data, :hard_wrap, :xhtml]
+    :safe_links_only, :with_toc_data, :hard_wrap, :prettify, :xhtml]
   
   def rename_extensions(exts)
     exts.map do |old_name|

data/lib/redcarpet/render_strip.rb

@@ -8,13 +8,13 @@ module Redcarpet
       [
         # block-level calls
         :block_code, :block_quote,
-        :block_html, :header, :list,
-        :list_item, :paragraph,
+        :block_html, :list, :list_item,
 
         # span-level calls
         :autolink, :codespan, :double_emphasis,
-        :emphasis, :raw_html, :triple_emphasis,
-        :strikethrough, :superscript,
+        :emphasis, :underline, :raw_html,
+        :triple_emphasis, :strikethrough,
+        :superscript,
 
         # low level rendering
         :entity, :normal_text
@@ -28,6 +28,14 @@ module Redcarpet
       def link(link, title, content)
         content
       end
+
+      def paragraph(text)
+        text + "\n"
+      end
+
+      def header(text, header_level)
+        text + "\n"
+      end
     end
   end
 end

data/redcarpet.gemspec

@@ -1,10 +1,10 @@
 # encoding: utf-8
 Gem::Specification.new do |s|
   s.name = 'redcarpet'
-  s.version = '2.2.2'
+  s.version = '2.3.0'
   s.summary = "Markdown that smells nice"
   s.description = 'A fast, safe and extensible Markdown to (X)HTML parser'
-  s.date = '2012-10-19'
+  s.date = '2013-05-22'
   s.email = 'vicent@github.com'
   s.homepage = 'http://github.com/vmg/redcarpet'
   s.authors = ["Natacha Porté", "Vicent Martí"]
@@ -12,7 +12,6 @@ Gem::Specification.new do |s|
   s.files = %w[
     COPYING
     Gemfile
-    Gemfile.lock
     README.markdown
     Rakefile
     bin/redcarpet
@@ -41,14 +40,26 @@ Gem::Specification.new do |s|
     lib/redcarpet/render_strip.rb
     redcarpet.gemspec
     sundown
-    test/redcarpet_test.rb
+    test/test_helper.rb
+    test/custom_render_test.rb
+    test/html_render_test.rb
+    test/markdown_test.rb
+    test/pathological_inputs_test.rb
+    test/redcarpet_compat_test.rb
+    test/smarty_html_test.rb
+    test/smarty_pants_test.rb
+    test/stripdown_render_test.rb
   ]
   # = MANIFEST =
-  s.test_files = ["test/redcarpet_test.rb"]
+  s.test_files = s.files.grep(%r{^test/})
   s.extra_rdoc_files = ["COPYING"]
   s.extensions = ["ext/redcarpet/extconf.rb"]
   s.executables = ["redcarpet"]
   s.require_paths = ["lib"]
+
   s.add_development_dependency "nokogiri"
   s.add_development_dependency "rake-compiler"
+  s.add_development_dependency "test-unit"
+  s.add_development_dependency "bluecloth"
+  s.add_development_dependency "kramdown"
 end

data/test/custom_render_test.rb

@@ -0,0 +1,28 @@
+# coding: UTF-8
+require 'test_helper'
+
+class CustomRenderTest < Test::Unit::TestCase
+  class SimpleRender < Redcarpet::Render::HTML
+    def emphasis(text)
+      "<em class=\"cool\">#{text}</em>"
+    end
+  end
+
+  def test_simple_overload
+    md = Redcarpet::Markdown.new(SimpleRender)
+    html_equal "<p>This is <em class=\"cool\">just</em> a test</p>\n",
+      md.render("This is *just* a test")
+  end
+
+  class NilPreprocessRenderer < Redcarpet::Render::HTML
+    def preprocess(fulldoc)
+      nil
+    end
+  end
+
+  def test_preprocess_returning_nil
+    md = Redcarpet::Markdown.new(NilPreprocessRenderer)
+    assert_equal(nil,md.render("Anything"))
+  end
+
+end

data/test/html_render_test.rb

@@ -0,0 +1,92 @@
+# coding: UTF-8
+require 'test_helper'
+
+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),
+      :escape_html => Redcarpet::Render::HTML.new(:escape_html => true),
+      :hard_wrap => Redcarpet::Render::HTML.new(:hard_wrap => 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&#39;link&quot;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&#39;link&quot;is</a></p>\n", rd
+  end
+end

data/test/{redcarpet_test.rb → markdown_test.rb}

@@ -1,139 +1,5 @@
 # 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'
-
-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
-
-class SmartyPantsTest < Test::Unit::TestCase
-  def setup
-    @pants = Redcarpet::Render::SmartyPants
-  end
-
-  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_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
-    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 = @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 = @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 = @pants.render("<p>what'd you say?</p>")
-    assert_equal "<p>what&rsquo;d you say?</p>", rd
-  end
-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),
-      :escape_html => Redcarpet::Render::HTML.new(:escape_html => true),
-      :hard_wrap => Redcarpet::Render::HTML.new(:hard_wrap => 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;
-
-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>", 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
-end
+require 'test_helper'
 
 class MarkdownTest < Test::Unit::TestCase
 
@@ -147,21 +13,21 @@ class MarkdownTest < Test::Unit::TestCase
 
   def test_that_simple_one_liner_goes_to_html
     assert_respond_to @markdown, :render
-    html_equal "<p>Hello World.</p>", @markdown.render("Hello World.")
+    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>", markdown
+    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>", markdown
+    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>", markdown
+    html_equal "<p>Run 'rake radiant:extensions:rbac_base:migrate'</p>\n", markdown
   end
 
   def test_that_urls_are_not_doubly_escaped
@@ -234,7 +100,7 @@ class MarkdownTest < Test::Unit::TestCase
       output = @markdown.render(input)
       assert_equal input.encoding.name, output.encoding.name
     end
-    
+
     def test_should_accept_non_utf8_or_ascii
       input = "testing \xAB\xCD".force_encoding('ASCII-8BIT')
       output = @markdown.render(input)
@@ -255,7 +121,7 @@ class MarkdownTest < Test::Unit::TestCase
 
   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>}
+    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
 
@@ -263,19 +129,19 @@ class MarkdownTest < Test::Unit::TestCase
     @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 @markdown.render(<<-header), "<h1>Body</h1>"
+    html_equal "<h1>Body</h1>\n", @markdown.render(<<-header)
 ######
 #Body#
 ######
@@ -294,6 +160,18 @@ EOS
     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~~"
 
@@ -302,6 +180,16 @@ EOS
     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_that_fenced_flag_works
     text = <<fenced
 This is a simple test
@@ -326,9 +214,29 @@ fenced
     assert !out.include?("<pre><code>")
   end
 
+  def test_that_prettify_works
+    text = "foo\nbar\n```\nsome\ncode\n```\nbaz"
+    out = Redcarpet::Markdown.new(Redcarpet::Render::HTML.new(:prettify => true), :fenced_code_blocks => true).render(text)
+    assert !out.include?("<pre><code class=\"prettyprint\">")
+  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>", markdown
+    html_equal "<h3>Hello <a href=\"http://github.com\">GitHub</a></h3>\n", markdown
   end
 
   def test_autolinking_with_ent_chars
@@ -344,104 +252,9 @@ text
   end
 
   def test_proper_intra_emphasis
-    md = Redcarpet::Markdown.new(Redcarpet::Render::HTML, :no_intra_emphasis => true)
     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>/
   end
 end
-
-class CustomRenderTest < Test::Unit::TestCase
-  class SimpleRender < Redcarpet::Render::HTML
-    def emphasis(text)
-      "<em class=\"cool\">#{text}</em>"
-    end
-  end
-
-  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
-
-  class NilPreprocessRenderer < Redcarpet::Render::HTML
-    def preprocess(fulldoc)
-      nil
-    end
-  end
-
-  def test_preprocess_returning_nil
-    md = Redcarpet::Markdown.new(NilPreprocessRenderer)
-    assert_equal(nil,md.render("Anything"))
-  end
-
-end
-
-class RedcarpetCompatTest < Test::Unit::TestCase
-  def test_simple_compat_api
-    html = RedcarpetCompat.new("This is_just_a test").to_html
-    html_equal "<p>This is<em>just</em>a test</p>", html
-  end
-  
-  def test_compat_api_enables_extensions
-    html = RedcarpetCompat.new("This is_just_a test", :no_intra_emphasis).to_html
-    html_equal "<p>This is_just_a test</p>", html
-  end
-
-  def test_compat_api_knows_fenced_code_extension
-    text = "```ruby\nx = 'foo'\n```"
-    html = RedcarpetCompat.new(text, :fenced_code).to_html
-    html_equal "<pre><code class=\"ruby\">x = 'foo'\n</code></pre>", html
-  end
-  
-  def test_compat_api_ignores_gh_blockcode_extension
-    text = "```ruby\nx = 'foo'\n```"
-    html = RedcarpetCompat.new(text, :fenced_code, :gh_blockcode).to_html
-    html_equal "<pre><code class=\"ruby\">x = 'foo'\n</code></pre>", html
-  end
-
-  def test_compat_api_knows_no_intraemphasis_extension
-    html = RedcarpetCompat.new("This is_just_a test", :no_intraemphasis).to_html
-    html_equal "<p>This is_just_a test</p>", html
-  end
-  
-  def test_translate_outdated_extensions
-    # these extensions are no longer used
-    exts = [:gh_blockcode, :no_tables, :smart, :strict]
-    html = RedcarpetCompat.new('"TEST"', *exts).to_html
-    html_equal "<p>&quot;TEST&quot;</p>", html
-  end
-end
-
-# 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_pathological_1
-    star = '*'  * 250000
-    @markdown.render("#{star}#{star} hi #{star}#{star}")
-  end
-
-  def test_pathological_2
-    crt = '^' * 255
-    str = "#{crt}(\\)"
-    @markdown.render("#{str*300}")
-  end
-
-  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