greenmat 3.2.0.2 → 3.2.2.0

data/ext/greenmat/markdown.h

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

data/greenmat.gemspec

@@ -21,8 +21,9 @@ Gem::Specification.new do |s|
   s.executables = ["greenmat"]
   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 "rspec", "~> 3.2"
   s.add_development_dependency "rubygems-xcodeproj_generator", '~> 0.1'
-  s.add_development_dependency "test-unit", "~> 3.0.9"
+  s.add_development_dependency "test-unit", "~> 2.5.4"
 end

data/lib/greenmat.rb

@@ -53,7 +53,7 @@ module Greenmat
           '>' => '>',
           '"' => '"',
           "'" => ''',
-          "/" => '/',
+          "/" => '&#x2F',
         })
       end
     end

data/lib/greenmat/compat.rb

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

data/lib/greenmat/version.rb

@@ -1,3 +1,3 @@
 module Greenmat
-  VERSION = '3.2.0.2'
+  VERSION = '3.2.2.0'
 end

data/tasks/greenmat.rake

@@ -3,6 +3,35 @@ namespace :greenmat do
   task :rename_project do
     ProjectRenamer.rename
   end
+
+  desc 'Set up git remote for redcarpet as `upstream`.'
+  task :setup_upstream do
+    sh 'git remote add upstream https://github.com/vmg/redcarpet.git'
+    sh 'git remote update'
+  end
+
+  desc 'Merge upstream branch while renaming project (BRANCH=branch_name).'
+  task :merge_upstream do
+    abort 'The current repository is not clean.' unless `git status --porcelain`.empty?
+
+    main_branch = `git rev-parse --abbrev-ref HEAD`.chomp
+    target_branch = ENV['BRANCH'] || 'upstream/master'
+    target_merge_branch = "merge-#{target_branch}"
+
+    puts "Merging #{target_branch.inspect} into #{main_branch.inspect}"
+
+    require 'fileutils'
+    Dir.mkdir('tmp') unless Dir.exist?('tmp')
+    FileUtils.cp('tasks/greenmat.rake', 'tmp')
+
+    sh 'git', 'checkout', '-B', target_merge_branch, target_branch
+    sh 'rake --rakefile tmp/greenmat.rake greenmat:rename_project'
+    sh 'git', 'add', '.'
+    sh 'git', 'commit', '--message', 'Rename project'
+
+    sh 'git', 'checkout', main_branch
+    sh 'git', 'merge', '--no-commit', '--strategy-option', 'theirs', target_merge_branch
+  end
 end
 
 module ProjectRenamer
@@ -22,7 +51,9 @@ module ProjectRenamer
     /^tasks\//,
     /^tmp\//,
     /\.(?:bundle|so)$/,
-    /README/
+    /README/,
+    /CHANGELOG.md/,
+    /CONTRIBUTING\.md/
   ]
 
   module_function

data/test/custom_render_test.rb

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

data/test/greenmat_compat_test.rb

@@ -4,35 +4,35 @@ require 'test_helper'
 class GreenmatCompatTest < Greenmat::TestCase
   def test_simple_compat_api
     html = GreenmatCompat.new("This is_just_a test").to_html
-    assert_equal "<p>This is<em>just</em>a test</p>\n", html
+    html_equal "<p>This is<em>just</em>a test</p>\n", html
   end
 
   def test_compat_api_enables_extensions
     html = GreenmatCompat.new("This is_just_a test", :no_intra_emphasis).to_html
-    assert_equal "<p>This is_just_a test</p>\n", html
+    html_equal "<p>This is_just_a test</p>\n", html
   end
 
   def test_compat_api_knows_fenced_code_extension
     text = "```ruby\nx = 'foo'\n```"
     html = GreenmatCompat.new(text, :fenced_code).to_html
-    assert_equal "<pre><code class=\"ruby\">x = &#39;foo&#39;\n</code></pre>\n", html
+    html_equal "<pre><code class=\"ruby\">x = 'foo'\n</code></pre>\n", html
   end
 
   def test_compat_api_ignores_gh_blockcode_extension
     text = "```ruby\nx = 'foo'\n```"
     html = GreenmatCompat.new(text, :fenced_code, :gh_blockcode).to_html
-    assert_equal "<pre><code class=\"ruby\">x = &#39;foo&#39;\n</code></pre>\n", html
+    html_equal "<pre><code class=\"ruby\">x = 'foo'\n</code></pre>\n", html
   end
 
   def test_compat_api_knows_no_intraemphasis_extension
     html = GreenmatCompat.new("This is_just_a test", :no_intraemphasis).to_html
-    assert_equal "<p>This is_just_a test</p>\n", html
+    html_equal "<p>This is_just_a test</p>\n", html
   end
 
   def test_translate_outdated_extensions
     # these extensions are no longer used
     exts = [:gh_blockcode, :no_tables, :smart, :strict]
     html = GreenmatCompat.new('"TEST"', *exts).to_html
-    assert_equal "<p>&quot;TEST&quot;</p>\n", html
+    html_equal "<p>&quot;TEST&quot;</p>\n", html
   end
 end

data/test/html_render_test.rb

@@ -3,7 +3,21 @@ require 'test_helper'
 
 class HTMLRenderTest < Greenmat::TestCase
   def setup
-    @renderer = Greenmat::Render::HTML
+    @markdown = Greenmat::Markdown.new(Greenmat::Render::HTML)
+    @rndr = {
+      :no_html => Greenmat::Render::HTML.new(:filter_html => true),
+      :no_images => Greenmat::Render::HTML.new(:no_images => true),
+      :no_links => Greenmat::Render::HTML.new(:no_links => true),
+      :safe_links => Greenmat::Render::HTML.new(:safe_links_only => true),
+      :escape_html => Greenmat::Render::HTML.new(:escape_html => true),
+      :hard_wrap => Greenmat::Render::HTML.new(:hard_wrap => true),
+      :toc_data => Greenmat::Render::HTML.new(:with_toc_data => true),
+      :prettify => Greenmat::Render::HTML.new(:prettify => true)
+    }
+  end
+
+  def render_with(rndr, text)
+    Greenmat::Markdown.new(rndr).render(text)
   end
 
   # Hint: overrides filter_html, no_images and no_links
@@ -23,55 +37,45 @@ EOS
 <p>&lt;img src=&quot;/favicon.ico&quot; /&gt;</p>
 EOE
 
-    assert_equal expected, render(source, with: [:escape_html])
+    markdown = render_with(@rndr[:escape_html], source)
+    html_equal expected, markdown
   end
 
   def test_that_filter_html_works
-    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
+    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 = "Lorem,  \nipsum\n"
-    output   = render(markdown, with: [:filter_html])
-
-    assert_equal "<p>Lorem,<br>\nipsum</p>\n", output
+    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
-    markdown = %(![dust mite](http://dust.mite/image.png) <img src="image.png" />)
-    output   = render(markdown, with: [:no_images])
-
-    assert_no_match %r{<img}, output
+    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
-    markdown = %([This link](http://example.net/) <a href="links.html">links</a>)
-    output   = render(markdown, with: [:no_links])
-
-    assert_no_match %r{<a }, output
+    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
-    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
+    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
-    markdown = <<EOE
+    rd = render_with(@rndr[:hard_wrap], <<EOE)
 Hello world,
 this is just a simple test
 
 With hard wraps
 and other *things*.
 EOE
-    output   = render(markdown, with: [:hard_wrap])
 
-    assert_match %r{<br>}, output
+    assert rd =~ /<br>/
   end
 
   def test_that_link_attributes_work
@@ -81,11 +85,11 @@ EOE
   end
 
   def test_that_link_works_with_quotes
-    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(Greenmat::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
 
-    assert_equal expected, render(markdown)
-    assert_equal expected, render(markdown, with: [:escape_html])
+    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
 
   def test_that_code_emphasis_work
@@ -107,19 +111,22 @@ However, this should be <em><code>an emphasised codespan</code></em></p>
 </ul>
 HTML
 
-    assert_equal html, render(markdown)
+    output = render_with(Greenmat::Render::HTML.new, markdown)
+    assert_equal html, output
   end
 
   def test_that_parenthesis_are_handled_into_links
-    markdown = %(The [bash man page](man:bash(1))!)
-    expected = %(<p>The <a href="man:bash(1)">bash man page</a>!</p>\n)
+    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(Greenmat::Render::HTML.new, markdown)
 
-    assert_equal expected, render(markdown)
+    assert_equal html, output
   end
 
   def test_autolinking_works_as_expected
-    markdown = "Uri ftp://user:pass@example.com/. Email foo@bar.com and link http://bar.com"
-    output   = render(markdown, with: [:autolink])
+    markdown = "Example of uri ftp://user:pass@example.com/. Email foo@bar.com and link http://bar.com"
+    renderer = Greenmat::Markdown.new(Greenmat::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'
@@ -148,7 +155,8 @@ MD
 </div>
 HTML
 
-    output = render(markdown, with: [:footnotes])
+    renderer = Greenmat::Markdown.new(Greenmat::Render::HTML, :footnotes => true)
+    output = renderer.render(markdown)
     assert_equal html, output
   end
 
@@ -164,78 +172,69 @@ MD
 <p>[^1] And a trailing definition</p>
 HTML
 
-    output = render(markdown, with: [:footnotes])
+    renderer = Greenmat::Markdown.new(Greenmat::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."
-    expected = "<p>Some text with a marker[^1] but no definition.</p>\n"
+    html = "<p>Some text with a marker[^1] but no definition.</p>\n"
 
-    output = render(markdown, with: [:footnotes])
-    assert_equal expected, output
+    renderer = Greenmat::Markdown.new(Greenmat::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"
-    output   = render(markdown, with: [:autolink])
+    renderer = Greenmat::Markdown.new(Greenmat::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_that_prettify_works
-    markdown = "\tclass Foo\nend"
-    output   = render(markdown, with: [:prettify])
+  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
 
-    assert output.include?("<pre><code class=\"prettyprint\">")
+  def test_that_prettify_works
+    text = <<-Markdown
+Foo
 
-    markdown = "`class`"
-    output   = render(markdown, with: [:prettify])
+~~~ruby
+some
+code
+~~~
 
-    assert output.include?("<code class=\"prettyprint\">")
-  end
+Bar
+Markdown
 
-  def test_prettify_with_fenced_code_blocks
-    markdown = "~~~ruby\ncode\n~~~"
-    output   = render(markdown, with: [:fenced_code_blocks, :prettify])
+    renderer = Greenmat::Markdown.new(@rndr[:prettify], fenced_code_blocks: true)
+    output = renderer.render(text)
 
-    assert output.include?("<code class=\"prettyprint lang-ruby\">")
+    assert output.include?("<code class=\"prettyprint ruby\">")
   end
 
   def test_safe_links_only_with_anchors
     markdown = "An [anchor link](#anchor) on a page."
-    output   = render(markdown, with: [:safe_links_only])
+
+    renderer = Greenmat::Markdown.new(@rndr[:safe_links])
+    output = renderer.render(markdown)
 
     assert_match %r{<a href="#anchor">anchor link</a>}, output
   end
 
   def test_autolink_with_link_attributes
-    options = { autolink: true, link_attributes: {rel: "nofollow"} }
-    output  = render("https://github.com/", with: options)
+    render = Greenmat::Render::HTML.new(link_attributes: {rel: "nofollow"})
+    parser = Greenmat::Markdown.new(render, autolink: true)
 
+    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

data/test/html_toc_render_test.rb

@@ -3,12 +3,13 @@ require 'test_helper'
 
 class HTMLTOCRenderTest < Greenmat::TestCase
   def setup
-    @renderer = Greenmat::Render::HTML_TOC
+    @render = Greenmat::Render::HTML_TOC
     @markdown = "# A title \n## A __nice__ subtitle\n## Another one \n### A sub-sub-title"
   end
 
   def test_simple_toc_render
-    output = render(@markdown).strip
+    renderer = Greenmat::Markdown.new(@render)
+    output = renderer.render(@markdown).strip
 
     assert output.start_with?("<ul>")
     assert output.end_with?("</ul>")
@@ -18,7 +19,8 @@ class HTMLTOCRenderTest < Greenmat::TestCase
   end
 
   def test_granular_toc_render
-    output = render(@markdown, with: { nesting_level: 2 }).strip
+    renderer = Greenmat::Markdown.new(@render.new(nesting_level: 2))
+    output = renderer.render(@markdown).strip
 
     assert output.start_with?("<ul>")
     assert output.end_with?("</ul>")
@@ -28,7 +30,8 @@ class HTMLTOCRenderTest < Greenmat::TestCase
   end
 
   def test_toc_heading_id
-    output = render(@markdown)
+    renderer = Greenmat::Markdown.new(@render)
+    output = renderer.render(@markdown)
 
     assert_match /a-title/, output
     assert_match /a-nice-subtitle/, output
@@ -37,40 +40,10 @@ class HTMLTOCRenderTest < Greenmat::TestCase
   end
 
   def test_toc_heading_with_hyphen_and_equal
-    output = render("# Hello World\n\n-\n\n=")
+    renderer = Greenmat::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
-
-  def test_anchor_generation_with_edge_cases
-    # Imported from ActiveSupport::Inflector#parameterize's tests
-    titles = {
-      "Donald E. Knuth"                     => "donald-e-knuth",
-      "Random text with *(bad)* characters" => "random-text-with-bad-characters",
-      "Trailing bad characters!@#"          => "trailing-bad-characters",
-      "!@#Leading bad characters"           => "leading-bad-characters",
-      "Squeeze   separators"                => "squeeze-separators",
-      "Test with + sign"                    => "test-with-sign",
-      "Test with a Namespaced::Class"       => "test-with-a-namespaced-class"
-    }
-
-    titles.each do |title, anchor|
-      assert_match anchor, render("# #{title}")
-    end
-  end
-
-  def test_inline_markup_is_not_escaped
-    output = render(@markdown)
-
-    assert_match "A <strong>nice</strong> subtitle", output
-    assert_no_match %r{&lt;}, output
-  end
-
-  def test_inline_markup_escaping
-    output = render(@markdown, with: [:escape_html])
-
-    assert_match "&lt;strong&gt;", output
-    assert_no_match %r{<strong>}, output
-  end
 end