greenmat 3.2.0.0

data/lib/greenmat/render_man.rb

@@ -0,0 +1,65 @@
+module Greenmat
+  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/greenmat/render_strip.rb

@@ -0,0 +1,48 @@
+module Greenmat
+  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, :list, :list_item,
+
+        # span-level calls
+        :autolink, :codespan, :double_emphasis,
+        :emphasis, :underline, :raw_html,
+        :triple_emphasis, :strikethrough,
+        :superscript,
+
+        # footnotes
+        :footnotes, :footnote_def, :footnote_ref,
+
+        # low level rendering
+        :entity, :normal_text
+      ].each do |method|
+        define_method method do |*args|
+          args.first
+        end
+      end
+
+      # Other methods where we don't return only a specific argument
+      def link(link, title, content)
+        "#{content} (#{link})"
+      end
+
+      def image(link, title, content)
+        content &&= content + " "
+        "#{content}#{link}"
+      end
+
+      def paragraph(text)
+        text + "\n"
+      end
+
+      def header(text, header_level)
+        text + "\n"
+      end
+    end
+  end
+end

data/test/benchmark.rb

@@ -0,0 +1,24 @@
+# coding: UTF-8
+# Thanks Kramdown for the inspiration!
+require 'benchmark/ips'
+
+require 'greenmat'
+require 'bluecloth'
+require 'kramdown'
+
+markdown = File.read(File.join(File.dirname(__FILE__), "fixtures/benchmark.md"))
+
+# Let's bench!
+Benchmark.ips do |bench|
+  bench.report("Greenmat") do
+    Greenmat::Markdown.new(Greenmat::Render::HTML).render(markdown)
+  end
+
+  bench.report("BlueCloth") do
+    BlueCloth.new(markdown).to_html
+  end
+
+  bench.report("Kramdown") do
+    Kramdown::Document.new(markdown).to_html
+  end
+end

data/test/custom_render_test.rb

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

data/test/greenmat_compat_test.rb

@@ -0,0 +1,38 @@
+# coding: UTF-8
+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
+  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
+  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
+  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
+  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
+  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
+  end
+end

data/test/html5_test.rb

@@ -0,0 +1,69 @@
+require 'test_helper'
+
+class HTML5Test < Greenmat::TestCase
+  def test_that_html5_works
+    section = <<EOS
+<section>
+  <p>The quick brown fox jumps over the lazy dog.</p>
+</section>
+EOS
+
+    figure = <<EOS
+<figure>
+  <img src="http://example.org/image.jpg" alt="">
+  <figcaption>
+    <p>Hello world!</p>
+  </figcaption>
+</figure>
+EOS
+
+    assert_renders section, section
+    assert_renders figure, figure
+  end
+
+  def test_that_html5_works_with_code_blocks
+    section = <<EOS
+\t<section>
+\t\t<p>The quick brown fox jumps over the lazy dog.</p>
+\t</section>
+EOS
+
+    section_expected = <<EOE
+<pre><code>&lt;section&gt;
+    &lt;p&gt;The quick brown fox jumps over the lazy dog.&lt;/p&gt;
+&lt;/section&gt;
+</code></pre>
+EOE
+
+    header = <<EOS
+    <header>
+        <hgroup>
+            <h1>Section heading</h1>
+            <h2>Subhead</h2>
+        </hgroup>
+    </header>
+EOS
+
+    header_expected = <<EOE
+<pre><code>&lt;header&gt;
+    &lt;hgroup&gt;
+        &lt;h1&gt;Section heading&lt;/h1&gt;
+        &lt;h2&gt;Subhead&lt;/h2&gt;
+    &lt;/hgroup&gt;
+&lt;/header&gt;
+</code></pre>
+EOE
+
+    assert_renders section_expected, section
+    assert_renders header_expected, header
+  end
+
+  def test_script_tag_recognition
+    markdown = <<-Md
+<script type="text/javascript">
+  alert('Foo!');
+</script>
+Md
+    assert_renders markdown, markdown
+  end
+end

data/test/html_render_test.rb

@@ -0,0 +1,241 @@
+# coding: UTF-8
+require 'test_helper'
+
+class HTMLRenderTest < Greenmat::TestCase
+  def setup
+    @renderer = Greenmat::Render::HTML
+  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
+
+    assert_equal expected, render(source, with: [:escape_html])
+  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
+  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
+  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
+  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
+  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
+  end
+
+  def test_that_hard_wrap_works
+    markdown = <<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
+  end
+
+  def test_that_link_attributes_work
+    rndr = Greenmat::Render::HTML.new(:link_attributes => {:rel => 'blank'})
+    md = Greenmat::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
+    markdown = %([This'link"is](http://example.net/))
+    expected = %(<p><a href="http://example.net/">This&#39;link&quot;is</a></p>\n)
+
+    assert_equal expected, render(markdown)
+    assert_equal expected, render(markdown, with: [:escape_html])
+  end
+
+  def test_that_code_emphasis_work
+    markdown = <<-MD
+This should be **`a bold codespan`**
+However, this should be *`an emphasised codespan`*
+
+* **`ABC`** or **`DEF`**
+* Foo bar
+MD
+
+    html = <<HTML
+<p>This should be <strong><code>a bold codespan</code></strong>
+However, this should be <em><code>an emphasised codespan</code></em></p>
+
+<ul>
+<li><strong><code>ABC</code></strong> or <strong><code>DEF</code></strong></li>
+<li>Foo bar</li>
+</ul>
+HTML
+
+    assert_equal html, render(markdown)
+  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)
+
+    assert_equal expected, render(markdown)
+  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])
+
+    assert output.include? '<a href="ftp://user:pass@example.com/">ftp://user:pass@example.com/</a>'
+    assert output.include? 'mailto:foo@bar.com'
+    assert output.include? '<a href="http://bar.com">'
+  end
+
+  def test_that_footnotes_work
+    markdown = <<-MD
+This is a footnote.[^1]
+
+[^1]: It provides additional information.
+MD
+
+    html = <<HTML
+<p>This is a footnote.<sup id="fnref1"><a href="#fn1" rel="footnote">1</a></sup></p>
+
+<div class="footnotes">
+<hr>
+<ol>
+
+<li id="fn1">
+<p>It provides additional information.&nbsp;<a href="#fnref1" rev="footnote">&#8617;</a></p>
+</li>
+
+</ol>
+</div>
+HTML
+
+    output = render(markdown, with: [:footnotes])
+    assert_equal html, output
+  end
+
+  def test_footnotes_enabled_but_missing_marker
+    markdown = <<MD
+Some text without a marker
+
+[^1] And a trailing definition
+MD
+    html = <<HTML
+<p>Some text without a marker</p>
+
+<p>[^1] And a trailing definition</p>
+HTML
+
+    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."
+    expected = "<p>Some text with a marker[^1] but no definition.</p>\n"
+
+    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"
+    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_that_prettify_works
+    markdown = "\tclass Foo\nend"
+    output   = render(markdown, with: [:prettify])
+
+    assert output.include?("<pre><code class=\"prettyprint\">")
+
+    markdown = "`class`"
+    output   = render(markdown, with: [:prettify])
+
+    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 lang-ruby\">")
+  end
+
+  def test_safe_links_only_with_anchors
+    markdown = "An [anchor link](#anchor) on a page."
+    output   = render(markdown, with: [:safe_links_only])
+
+    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)
+
+    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