vkhater-redcarpet 2.2.3

data/ext/redcarpet/redcarpet.h

@@ -0,0 +1,37 @@
+#ifndef REDCARPET_H__
+#define REDCARPET_H__
+
+#define RSTRING_NOT_MODIFIED
+#include "ruby.h"
+#include <stdio.h>
+
+#ifdef HAVE_RUBY_ENCODING_H
+#	include <ruby/encoding.h>
+#	define redcarpet_str_new(data, size, enc) rb_enc_str_new(data, size, enc)
+#else
+#	define redcarpet_str_new(data, size, enc) rb_str_new(data, size)
+#endif
+
+#include "markdown.h"
+#include "html.h"
+
+#define CSTR2SYM(s) (ID2SYM(rb_intern((s))))
+
+extern void Init_redcarpet_rndr();
+
+struct redcarpet_renderopt {
+	struct html_renderopt html;
+	VALUE link_attributes;
+	VALUE self;
+	VALUE base_class;
+#ifdef HAVE_RUBY_ENCODING_H
+	rb_encoding *active_enc;
+#endif
+};
+
+struct rb_redcarpet_rndr {
+	struct sd_callbacks callbacks;
+	struct redcarpet_renderopt options;
+};
+
+#endif

data/ext/redcarpet/stack.c

@@ -0,0 +1,81 @@
+#include "stack.h"
+#include <string.h>
+
+int
+stack_grow(struct stack *st, size_t new_size)
+{
+	void **new_st;
+
+	if (st->asize >= new_size)
+		return 0;
+
+	new_st = realloc(st->item, new_size * sizeof(void *));
+	if (new_st == NULL)
+		return -1;
+
+	memset(new_st + st->asize, 0x0,
+		(new_size - st->asize) * sizeof(void *));
+
+	st->item = new_st;
+	st->asize = new_size;
+
+	if (st->size > new_size)
+		st->size = new_size;
+
+	return 0;
+}
+
+void
+stack_free(struct stack *st)
+{
+	if (!st)
+		return;
+
+	free(st->item);
+
+	st->item = NULL;
+	st->size = 0;
+	st->asize = 0;
+}
+
+int
+stack_init(struct stack *st, size_t initial_size)
+{
+	st->item = NULL;
+	st->size = 0;
+	st->asize = 0;
+
+	if (!initial_size)
+		initial_size = 8;
+
+	return stack_grow(st, initial_size);
+}
+
+void *
+stack_pop(struct stack *st)
+{
+	if (!st->size)
+		return NULL;
+
+	return st->item[--st->size];
+}
+
+int
+stack_push(struct stack *st, void *item)
+{
+	if (stack_grow(st, st->size * 2) < 0)
+		return -1;
+
+	st->item[st->size++] = item;
+	return 0;
+}
+
+void *
+stack_top(struct stack *st)
+{
+	if (!st->size)
+		return NULL;
+
+	return st->item[st->size - 1];
+}
+

data/ext/redcarpet/stack.h

@@ -0,0 +1,29 @@
+#ifndef STACK_H__
+#define STACK_H__
+
+#include <stdlib.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct stack {
+	void **item;
+	size_t size;
+	size_t asize;
+};
+
+void stack_free(struct stack *);
+int stack_grow(struct stack *, size_t);
+int stack_init(struct stack *, size_t);
+
+int stack_push(struct stack *, void *);
+
+void *stack_pop(struct stack *);
+void *stack_top(struct stack *);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/lib/redcarpet.rb

@@ -0,0 +1,124 @@
+require 'redcarpet.so'
+
+module Redcarpet
+  VERSION = '2.2.2'
+
+  class Markdown
+    attr_reader :renderer
+  end
+
+  module Render
+
+    # XHTML Renderer
+    class XHTML < HTML
+      def initialize(extensions={})
+        super(extensions.merge(:xhtml => true))
+      end
+    end
+
+    # HTML + SmartyPants renderer
+    class SmartyHTML < HTML
+      include SmartyPants
+    end
+
+    # SmartyPants Mixin module
+    #
+    # Implements SmartyPants.postprocess, which
+    # performs smartypants replacements on the HTML file,
+    # once it has been fully rendered.
+    #
+    # To add SmartyPants postprocessing to your custom
+    # renderers, just mixin the module `include SmartyPants`
+    #
+    # You can also use this as a standalone SmartyPants
+    # implementation.
+    #
+    # Example:
+    #
+    #   # Mixin
+    #   class CoolRenderer < HTML
+    #     include SmartyPants
+    #     # more code here
+    #   end
+    #
+    #   # Standalone
+    #   Redcarpet::Render::SmartyPants.render("you're")
+    #
+    module SmartyPants
+      extend self
+      def self.render(text)
+        postprocess text
+      end
+    end
+  end
+end
+
+# Compatibility class;
+# Creates an instance of Redcarpet with the RedCloth API.
+class RedcarpetCompat
+  attr_accessor :text
+
+  def initialize(text, *exts)
+    exts_hash, render_hash = *parse_extensions_and_renderer_options(exts)
+    @text = text
+    renderer = Redcarpet::Render::HTML.new(render_hash)
+    @markdown = Redcarpet::Markdown.new(renderer, exts_hash)
+  end
+
+  def to_html(*_dummy)
+    @markdown.render(@text)
+  end
+  
+  private
+  
+  EXTENSION_MAP = {
+    # old name => new name
+    :autolink => :autolink,
+    :fenced_code => :fenced_code_blocks,
+    :filter_html => :filter_html,
+    :hard_wrap => :hard_wrap,
+    :lax_htmlblock => :lax_spacing,
+    :no_image => :no_images,
+    :no_intraemphasis => :no_intra_emphasis,
+    :no_links => :no_links,
+    :filter_styles => :no_styles,
+    :safelink => :safe_links_only,
+    :space_header => :space_after_headers,
+    :strikethrough => :strikethrough,
+    :tables => :tables,
+    :generate_toc => :with_toc_data,
+    :xhtml => :xhtml,
+    # old names with no new mapping
+    :gh_blockcode => nil,
+    :no_tables => nil,
+    :smart => nil,
+    :strict => nil
+  }
+  
+  RENDERER_OPTIONS = [:filter_html, :no_images, :no_links, :no_styles, 
+    :safe_links_only, :with_toc_data, :hard_wrap, :xhtml]
+  
+  def rename_extensions(exts)
+    exts.map do |old_name|
+      if new_name = EXTENSION_MAP[old_name]
+        new_name
+      else
+        old_name
+      end
+    end.compact
+  end
+  
+  # Returns two hashes, the extensions and renderer options
+  # given the extension list
+  def parse_extensions_and_renderer_options(exts)
+    exts = rename_extensions(exts)
+    exts.partition {|ext| !RENDERER_OPTIONS.include?(ext) }.
+      map {|list| list_to_truthy_hash(list) }
+  end
+  
+  # Turns a list of symbols into a hash of <tt>symbol => true</tt>.
+  def list_to_truthy_hash(list)
+    list.inject({}) {|h, k| h[k] = true; h }
+  end
+end
+

data/lib/redcarpet/compat.rb

@@ -0,0 +1,3 @@
+require 'redcarpet'
+
+Markdown = RedcarpetCompat unless defined? Markdown

data/lib/redcarpet/render_man.rb

@@ -0,0 +1,65 @@
+module Redcarpet
+  module Render
+    class ManPage < Base
+
+      def normal_text(text)
+        text.gsub('-', '\\-').strip
+      end
+
+      def block_code(code, language)
+        "\n.nf\n#{normal_text(code)}\n.fi\n"
+      end
+
+      def codespan(code)
+        block_code(code, nil)
+      end
+
+      def header(title, level)
+        case level
+        when 1
+          "\n.TH #{title}\n"
+
+        when 2
+          "\n.SH #{title}\n"
+
+        when 3
+          "\n.SS #{title}\n"
+        end
+      end
+
+      def double_emphasis(text)
+        "\\fB#{text}\\fP"
+      end
+
+      def emphasis(text)
+        "\\fI#{text}\\fP"
+      end
+
+      def linebreak
+        "\n.LP\n"
+      end
+
+      def paragraph(text)
+        "\n.TP\n#{text}\n"
+      end
+
+      def list(content, list_type)
+        case list_type
+        when :ordered
+          "\n\n.nr step 0 1\n#{content}\n"
+        when :unordered
+          "\n.\n#{content}\n"
+        end
+      end
+
+      def list_item(content, list_type)
+        case list_type
+        when :ordered
+          ".IP \\n+[step]\n#{content.strip}\n"
+        when :unordered
+          ".IP \\[bu] 2 \n#{content.strip}\n"
+        end
+      end
+    end
+  end
+end

data/lib/redcarpet/render_strip.rb

@@ -0,0 +1,33 @@
+
+module Redcarpet
+  module Render
+    # Markdown-stripping renderer. Turns Markdown into plaintext
+    # Thanks to @toupeira (Markus Koller)
+    class StripDown < Base
+      # Methods where the first argument is the text content
+      [
+        # block-level calls
+        :block_code, :block_quote,
+        :block_html, :header, :list,
+        :list_item, :paragraph,
+
+        # span-level calls
+        :autolink, :codespan, :double_emphasis,
+        :emphasis, :raw_html, :triple_emphasis,
+        :strikethrough, :superscript,
+
+        # low level rendering
+        :entity, :normal_text
+      ].each do |method|
+        define_method method do |*args|
+          args.first
+        end
+      end
+
+      # Other methods where the text content is in another argument
+      def link(link, title, content)
+        content
+      end
+    end
+  end
+end

data/redcarpet.gemspec

@@ -0,0 +1,54 @@
+# encoding: utf-8
+Gem::Specification.new do |s|
+  s.name = 'vkhater-redcarpet'
+  s.version = '2.2.3'
+  s.summary = "Markdown that smells nice"
+  s.description = 'A fast, safe and extensible Markdown to (X)HTML parser'
+  s.date = '2012-10-19'
+  s.email = 'vicent@github.com'
+  s.homepage = 'http://github.com/vmg/redcarpet'
+  s.authors = ["Natacha Porté", "Vicent Martí"]
+  # = MANIFEST =
+  s.files = %w[
+    COPYING
+    Gemfile
+    Gemfile.lock
+    README.markdown
+    Rakefile
+    bin/redcarpet
+    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/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/compat.rb
+    lib/redcarpet/render_man.rb
+    lib/redcarpet/render_strip.rb
+    redcarpet.gemspec
+    sundown
+    test/redcarpet_test.rb
+  ]
+  # = MANIFEST =
+  s.test_files = ["test/redcarpet_test.rb"]
+  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"
+end

data/test/redcarpet_test.rb

@@ -0,0 +1,447 @@
+# 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
+
+class MarkdownTest < Test::Unit::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>", @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
+  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
+
+    markdown = @markdown.render("Run 'rake radiant:extensions:rbac_base:migrate'")
+    html_equal "<p>Run 'rake radiant:extensions:rbac_base:migrate'</p>", 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
+
+  # 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_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
+
+  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
+
+    def test_should_return_string_in_same_encoding_not_in_utf8
+      input = "testing".encode('US-ASCII')
+      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)
+      assert_equal 'ASCII-8BIT', 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
+    @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>"
+######
+#Body#
+######
+    header
+  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_strikethrough_flag_works
+    text = "this is ~some~ striked ~~text~~"
+
+    assert render_with({}, text) !~ /<del/
+
+    assert render_with({:strikethrough => true}, text) =~ /<del/
+  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_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
+
+  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
+    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