redcarpet 3.2.3 → 3.3.0

data/ext/redcarpet/markdown.h

@@ -104,9 +104,6 @@ struct sd_callbacks {
 	void (*doc_footer)(struct buf *ob, void *opaque);
 };
 
-/* header methods used internally in Redcarpet */
-char* header_anchor(struct buf *text);
-
 struct sd_markdown;
 
 /*********

data/ext/redcarpet/rc_markdown.c

@@ -122,13 +122,9 @@ static VALUE rb_redcarpet_md_render(VALUE self, VALUE text)
 	if (NIL_P(text))
 		return Qnil;
 
-#ifdef HAVE_RUBY_ENCODING_H
-	{
-		struct rb_redcarpet_rndr *renderer;
-		Data_Get_Struct(rb_rndr, struct rb_redcarpet_rndr, renderer);
-		renderer->options.active_enc = rb_enc_get(text);
-	}
-#endif
+	struct rb_redcarpet_rndr *renderer;
+	Data_Get_Struct(rb_rndr, struct rb_redcarpet_rndr, renderer);
+	renderer->options.active_enc = rb_enc_get(text);
 
 	/* initialize buffers */
 	output_buf = bufnew(128);

data/ext/redcarpet/rc_render.c

@@ -472,25 +472,30 @@ static VALUE rb_redcarpet_html_init(int argc, VALUE *argv, VALUE self)
 static VALUE rb_redcarpet_htmltoc_init(int argc, VALUE *argv, VALUE self)
 {
 	struct rb_redcarpet_rndr *rndr;
-	int nesting_level = 6;
-	VALUE hash, key = Qnil;
+	unsigned int render_flags = HTML_TOC;
+	VALUE hash, nesting_level = Qnil;
 
 	Data_Get_Struct(self, struct rb_redcarpet_rndr, rndr);
 
 	if (rb_scan_args(argc, argv, "01", &hash) == 1) {
 		Check_Type(hash, T_HASH);
 
-		key = CSTR2SYM("nesting_level");
+		/* escape_html */
+		if (rb_hash_aref(hash, CSTR2SYM("escape_html")) == Qtrue)
+			render_flags |= HTML_ESCAPE;
 
-		if (RTEST(rb_hash_aref(hash, key))) {
-			Check_Type(rb_hash_aref(hash, key), T_FIXNUM);
-			nesting_level = NUM2INT(rb_hash_aref(hash, key));
-		}
+		/* Nesting level */
+		nesting_level = rb_hash_aref(hash, CSTR2SYM("nesting_level"));
 	}
 
-	sdhtml_toc_renderer(&rndr->callbacks, (struct html_renderopt *)&rndr->options.html, nesting_level);
+	sdhtml_toc_renderer(&rndr->callbacks, (struct html_renderopt *)&rndr->options.html, render_flags);
 	rb_redcarpet__overload(self, rb_cRenderHTML_TOC);
 
+	if (!(NIL_P(nesting_level)))
+		rndr->options.html.toc_data.nesting_level = NUM2INT(nesting_level);
+	else
+		rndr->options.html.toc_data.nesting_level = 6;
+
 	return Qnil;
 }
 

data/lib/redcarpet.rb

@@ -2,7 +2,7 @@ require 'redcarpet.so'
 require 'redcarpet/compat'
 
 module Redcarpet
-  VERSION = '3.2.3'
+  VERSION = '3.3.0'
 
   class Markdown
     attr_reader :renderer

data/lib/redcarpet/compat.rb

@@ -1,8 +1,5 @@
 require 'redcarpet'
 
-# Deprecated: Please use the default API to parse Markdown
-# documents ; this layer will be removed in Redcarpet 4.0.
-#
 # Creates an instance of Redcarpet with the RedCloth API.
 class RedcarpetCompat
   attr_accessor :text

data/redcarpet.gemspec

@@ -1,10 +1,10 @@
 # encoding: utf-8
 Gem::Specification.new do |s|
   s.name = 'redcarpet'
-  s.version = '3.2.3'
+  s.version = '3.3.0'
   s.summary = "Markdown that smells nice"
   s.description = 'A fast, safe and extensible Markdown to (X)HTML parser'
-  s.date = '2015-04-05'
+  s.date = '2015-06-05'
   s.email = 'vicent@github.com'
   s.homepage = 'http://github.com/vmg/redcarpet'
   s.authors = ["Natacha Porté", "Vicent Martí"]
@@ -43,11 +43,13 @@ Gem::Specification.new do |s|
     redcarpet.gemspec
     test/benchmark.rb
     test/custom_render_test.rb
+    test/fixtures/benchmark.md
     test/html5_test.rb
     test/html_render_test.rb
     test/html_toc_render_test.rb
     test/markdown_test.rb
     test/pathological_inputs_test.rb
+    test/redcarpet_bin_test.rb
     test/redcarpet_compat_test.rb
     test/safe_render_test.rb
     test/smarty_html_test.rb
@@ -62,7 +64,6 @@ Gem::Specification.new do |s|
   s.executables = ["redcarpet"]
   s.require_paths = ["lib"]
 
-  s.add_development_dependency "nokogiri", "~> 1.6.0"
   s.add_development_dependency "rake-compiler", "~> 0.8.3"
-  s.add_development_dependency "test-unit", "~> 2.5.4"
+  s.add_development_dependency "test-unit", "~> 3.0.9"
 end

data/test/custom_render_test.rb

@@ -10,7 +10,7 @@ class CustomRenderTest < Redcarpet::TestCase
 
   def test_simple_overload
     md = Redcarpet::Markdown.new(SimpleRender)
-    html_equal "<p>This is <em class=\"cool\">just</em> a test</p>\n",
+    assert_equal "<p>This is <em class=\"cool\">just</em> a test</p>\n",
       md.render("This is *just* a test")
   end
 

data/test/fixtures/benchmark.md

@@ -0,0 +1,232 @@
+Download
+--------
+
+[Markdown 1.0.1][dl] (18 KB) -- 17 Dec 2004
+
+[dl]: http://daringfireball.net/projects/downloads/Markdown_1.0.1.zip
+
+
+Introduction
+------------
+
+Markdown is a text-to-HTML conversion tool for web writers. Markdown
+allows you to write using an easy-to-read, easy-to-write plain text
+format, then convert it to structurally valid XHTML (or HTML).
+
+Thus, "Markdown" is two things: (1) a plain text formatting syntax;
+and (2) a software tool, written in Perl, that converts the plain text
+formatting to HTML. See the [Syntax][] page for details pertaining to
+Markdown's formatting syntax. You can try it out, right now, using the
+online [Dingus][].
+
+  [syntax]: /projects/markdown/syntax
+  [dingus]: /projects/markdown/dingus
+
+The overriding design goal for Markdown's formatting syntax is to make
+it as readable as possible. The idea is that a Markdown-formatted
+document should be publishable as-is, as plain text, without looking
+like it's been marked up with tags or formatting instructions. While
+Markdown's syntax has been influenced by several existing text-to-HTML
+filters, the single biggest source of inspiration for Markdown's
+syntax is the format of plain text email.
+
+The best way to get a feel for Markdown's formatting syntax is simply
+to look at a Markdown-formatted document. For example, you can view
+the Markdown source for the article text on this page here:
+<http://daringfireball.net/projects/markdown/index.text>
+
+(You can use this '.text' suffix trick to view the Markdown source for
+the content of each of the pages in this section, e.g. the
+[Syntax][s_src] and [License][l_src] pages.)
+
+  [s_src]: /projects/markdown/syntax.text
+  [l_src]: /projects/markdown/license.text
+
+Markdown is free software, available under a BSD-style open source
+license. See the [License] [pl] page for more information.
+
+  [pl]: /projects/markdown/license
+
+
+Discussion List <a id="discussion-list" />
+---------------
+
+I've set up a public [mailing list for discussion about Markdown] [ml].
+Any topic related to Markdown -- both its formatting syntax and
+its software -- is fair game for discussion. Anyone who is interested
+is welcome to join.
+
+It's my hope that the mailing list will lead to good ideas for future
+improvements to Markdown.
+
+  [ml]: http://six.pairlist.net/mailman/listinfo/markdown-discuss
+
+
+Installation and Requirements <a id="install" />
+-----------------------------
+
+Markdown requires Perl 5.6.0 or later. Welcome to the 21st Century.
+Markdown also requires the standard Perl library module [Digest::MD5]
+[md5], which is probably already installed on your server.
+
+  [md5]: http://search.cpan.org/dist/Digest-MD5/MD5.pm
+
+
+### Movable Type ###
+
+Markdown works with Movable Type version 2.6 or later (including
+Movable Type 3.0).
+
+1.  Copy the "Markdown.pl" file into your Movable Type "plugins"
+  directory. The "plugins" directory should be in the same directory
+  as "mt.cgi"; if the "plugins" directory doesn't already exist, use
+  your FTP program to create it. Your installation should look like
+  this:
+
+        (mt home)/plugins/Markdown.pl
+
+2.  Once installed, Markdown will appear as an option in Movable Type's
+  Text Formatting pop-up menu. This is selectable on a per-post basis:
+
+  ![Screenshot of Movable Type 'Text Formatting' Menu][tfmenu]
+
+  Markdown translates your posts to HTML when you publish; the posts
+  themselves are stored in your MT database in Markdown format.
+
+3.  If you also install SmartyPants 1.5 (or later), Markdown will
+  offer a second text formatting option: "Markdown With
+  SmartyPants". This option is the same as the regular "Markdown"
+  formatter, except that it automatically uses SmartyPants to create
+  typographically correct curly quotes, em-dashes, and ellipses. See
+  the [SmartyPants web page][sp] for more information.
+
+4.  To make Markdown (or "Markdown With SmartyPants") your default
+  text formatting option for new posts, go to Weblog Config:
+  Preferences.
+
+Note that by default, Markdown produces XHTML output. To configure
+Markdown to produce HTML 4 output, see "Configuration", below.
+
+  [sp]: http://daringfireball.net/projects/smartypants/
+
+
+
+### Blosxom ###
+
+Markdown works with Blosxom version 2.0 or later.
+
+1.  Rename the "Markdown.pl" plug-in to "Markdown" (case is
+    important). Movable Type requires plug-ins to have a ".pl"
+    extension; Blosxom forbids it.
+
+2.  Copy the "Markdown" plug-in file to your Blosxom plug-ins folder.
+    If you're not sure where your Blosxom plug-ins folder is, see the
+    Blosxom documentation for information.
+
+3.  That's it. The entries in your weblog will now automatically be
+  processed by Markdown.
+
+4.  If you'd like to apply Markdown formatting only to certain
+  posts, rather than all of them, Markdown can optionally be used in
+  conjunction with Blosxom's [Meta][] plug-in. First, install the
+  Meta plug-in. Next, open the Markdown plug-in file in a text
+  editor, and set the configuration variable `$g_blosxom_use_meta`
+  to 1. Then, simply include a "`meta-markup: Markdown`" header line
+  at the top of each post you compose using Markdown.
+
+  [meta]: http://www.blosxom.com/plugins/meta/meta.htm
+
+
+### BBEdit ###
+
+Markdown works with BBEdit 6.1 or later on Mac OS X. It also works
+with BBEdit 5.1 or later and MacPerl 5.6.1 on Mac OS 8.6 or later. If
+you're running Mac OS X 10.2 (Jaguar), you may need to install the
+Perl module [Digest::MD5] [md5] from CPAN; Digest::MD5 comes
+pre-installed on Mac OS X 10.3 (Panther).
+
+1.  Copy the "Markdown.pl" file to appropriate filters folder in your
+  "BBEdit Support" folder. On Mac OS X, this should be:
+
+        BBEdit Support/Unix Support/Unix Filters/
+
+    See the BBEdit documentation for more details on the location of
+    these folders.
+
+    You can rename "Markdown.pl" to whatever you wish.
+
+2.  That's it. To use Markdown, select some text in a BBEdit document,
+  then choose Markdown from the Filters sub-menu in the "#!" menu, or
+  the Filters floating palette
+
+
+
+Configuration  <a id="configuration"></a>
+-------------
+
+By default, Markdown produces XHTML output for tags with empty elements.
+E.g.:
+
+    <br />
+
+Markdown can be configured to produce HTML-style tags; e.g.:
+
+    <br>
+
+
+### Movable Type ###
+
+You need to use a special `MTMarkdownOptions` container tag in each
+Movable Type template where you want HTML 4-style output:
+
+    <MTMarkdownOptions output='html4'>
+        ... put your entry content here ...
+    </MTMarkdownOptions>
+
+The easiest way to use MTMarkdownOptions is probably to put the
+opening tag right after your `<body>` tag, and the closing tag right
+before `</body>`.
+
+To suppress Markdown processing in a particular template, i.e. to
+publish the raw Markdown-formatted text without translation into
+(X)HTML, set the `output` attribute to 'raw':
+
+    <MTMarkdownOptions output='raw'>
+        ... put your entry content here ...
+    </MTMarkdownOptions>
+
+
+### Command-Line ###
+
+Use the `--html4tags` command-line switch to produce HTML output from a
+Unix-style command line. E.g.:
+
+    % perl Markdown.pl --html4tags foo.text
+
+Type `perldoc Markdown.pl`, or read the POD documentation within the
+Markdown.pl source code for more information.
+
+
+Acknowledgements <a id="acknowledgements" />
+----------------
+
+[Aaron Swartz][] deserves a tremendous amount of credit for his feedback on the
+design of Markdown's formatting syntax. Markdown is *much* better thanks
+to Aaron's ideas, feedback, and testing. Also, Aaron's [html2text][]
+is a very handy (and free) utility for turning HTML into
+Markdown-formatted plain text.
+
+[Nathaniel Irons][], [Dan Benjamin][], [Daniel Bogan][], and [Jason Perkins][]
+also deserve thanks for their feedback.
+
+[Michel Fortin][] has ported Markdown to PHP; it's a splendid port, and highly recommended for anyone looking for a PHP implementation of Markdown.
+
+  [Aaron Swartz]:   http://www.aaronsw.com/
+  [Nathaniel Irons]:  http://bumppo.net/
+  [Dan Benjamin]:   http://hivelogic.com/
+  [Daniel Bogan]:   http://waferbaby.com/
+  [Jason Perkins]:    http://pressedpants.com/
+  [Michel Fortin]:    http://www.michelf.com/projects/php-markdown/
+  [html2text]:          http://www.aaronsw.com/2002/html2text/
+
+  [tfmenu]: /graphics/markdown/mt_textformat_menu.png

data/test/html_render_test.rb

@@ -3,21 +3,7 @@ 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)
+    @renderer = Redcarpet::Render::HTML
   end
 
   # Hint: overrides filter_html, no_images and no_links
@@ -37,45 +23,55 @@ EOS
 <p>&lt;img src=&quot;/favicon.ico&quot; /&gt;</p>
 EOE
 
-    markdown = render_with(@rndr[:escape_html], source)
-    html_equal expected, markdown
+    assert_equal expected, render(source, with: [:escape_html])
   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
+    markdown = 'Through <em>NO</em> <script>DOUBLE NO</script>'
+    output   = render(markdown, with: [:filter_html])
+
+    assert_equal "<p>Through NO DOUBLE NO</p>\n", output
   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
+    markdown = "Lorem,  \nipsum\n"
+    output   = render(markdown, with: [:filter_html])
+
+    assert_equal "<p>Lorem,<br>\nipsum</p>\n", output
   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/
+    markdown = %(![dust mite](http://dust.mite/image.png) <img src="image.png" />)
+    output   = render(markdown, with: [:no_images])
+
+    assert_no_match %r{<img}, output
   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 /
+    markdown = %([This link](http://example.net/) <a href="links.html">links</a>)
+    output   = render(markdown, with: [:no_links])
+
+    assert_no_match %r{<a }, output
   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
+    markdown = "[IRC](irc://chat.freenode.org/#freenode)"
+    output   = render(markdown, with: [:safe_links_only])
+
+    assert_equal "<p>[IRC](irc://chat.freenode.org/#freenode)</p>\n", output
   end
 
   def test_that_hard_wrap_works
-    rd = render_with(@rndr[:hard_wrap], <<EOE)
+    markdown = <<EOE
 Hello world,
 this is just a simple test
 
 With hard wraps
 and other *things*.
 EOE
+    output   = render(markdown, with: [:hard_wrap])
 
-    assert rd =~ /<br>/
+    assert_match %r{<br>}, output
   end
 
   def test_that_link_attributes_work
@@ -85,11 +81,11 @@ EOE
   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
+    markdown = %([This'link"is](http://example.net/))
+    expected = %(<p><a href="http://example.net/">This&#39;link&quot;is</a></p>\n)
 
-    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
+    assert_equal expected, render(markdown)
+    assert_equal expected, render(markdown, with: [:escape_html])
   end
 
   def test_that_code_emphasis_work
@@ -111,22 +107,19 @@ However, this should be <em><code>an emphasised codespan</code></em></p>
 </ul>
 HTML
 
-    output = render_with(Redcarpet::Render::HTML.new, markdown)
-    assert_equal html, output
+    assert_equal html, render(markdown)
   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)
+    markdown = %(The [bash man page](man:bash(1))!)
+    expected = %(<p>The <a href="man:bash(1)">bash man page</a>!</p>\n)
 
-    assert_equal html, output
+    assert_equal expected, render(markdown)
   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)
+    markdown = "Uri ftp://user:pass@example.com/. Email foo@bar.com and link http://bar.com"
+    output   = render(markdown, with: [:autolink])
 
     assert output.include? '<a href="ftp://user:pass@example.com/">ftp://user:pass@example.com/</a>'
     assert output.include? 'mailto:foo@bar.com'
@@ -155,8 +148,7 @@ MD
 </div>
 HTML
 
-    renderer = Redcarpet::Markdown.new(Redcarpet::Render::HTML, :footnotes => true)
-    output = renderer.render(markdown)
+    output = render(markdown, with: [:footnotes])
     assert_equal html, output
   end
 
@@ -172,69 +164,78 @@ MD
 <p>[^1] And a trailing definition</p>
 HTML
 
-    renderer = Redcarpet::Markdown.new(Redcarpet::Render::HTML, :footnotes => true)
-    output = renderer.render(markdown)
+    output = render(markdown, with: [:footnotes])
     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"
+    expected = "<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
+    output = render(markdown, with: [:footnotes])
+    assert_equal expected, 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)
+    output   = render(markdown, with: [:autolink])
 
     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
+    markdown = "\tclass Foo\nend"
+    output   = render(markdown, with: [:prettify])
 
-~~~ruby
-some
-code
-~~~
+    assert output.include?("<pre><code class=\"prettyprint\">")
 
-Bar
-Markdown
+    markdown = "`class`"
+    output   = render(markdown, with: [:prettify])
 
-    renderer = Redcarpet::Markdown.new(@rndr[:prettify], fenced_code_blocks: true)
-    output = renderer.render(text)
+    assert output.include?("<code class=\"prettyprint\">")
+  end
+
+  def test_prettify_with_fenced_code_blocks
+    markdown = "~~~ruby\ncode\n~~~"
+    output   = render(markdown, with: [:fenced_code_blocks, :prettify])
 
-    assert output.include?("<code class=\"prettyprint ruby\">")
+    assert output.include?("<code class=\"prettyprint lang-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)
+    output   = render(markdown, with: [:safe_links_only])
 
     assert_match %r{<a href="#anchor">anchor link</a>}, output
   end
 
   def test_autolink_with_link_attributes
-    render = Redcarpet::Render::HTML.new(link_attributes: {rel: "nofollow"})
-    parser = Redcarpet::Markdown.new(render, autolink: true)
+    options = { autolink: true, link_attributes: {rel: "nofollow"} }
+    output  = render("https://github.com/", with: options)
 
-    output = parser.render("https://github.com/")
     assert_match %r{rel="nofollow"}, output
   end
+
+  def test_image_unsafe_src_with_safe_links_only
+    markdown = "![foo](javascript:while(1);)"
+    output   = render(markdown, with: [:safe_links_only])
+
+    assert_not_match %r{img src}, output
+  end
+
+  def test_no_styles_option_inside_a_paragraph
+    markdown = "Hello <style> foo { bar: baz; } </style> !"
+    output   = render(markdown, with: [:no_styles])
+
+    assert_no_match %r{<style>}, output
+  end
+
+  def test_no_styles_inside_html_block_rendering
+    markdown = "<style> foo { bar: baz; } </style>"
+    output   = render(markdown, with: [:no_styles])
+
+    assert_no_match %r{<style>}, output
+  end
 end