qiita_marker 0.23.2.0

data/test/test_extensions.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class TestExtensions < Minitest::Test
+  def setup
+    @markdown = fixtures_file('table.md')
+  end
+
+  def test_uses_specified_extensions
+    QiitaMarker.render_html(@markdown, :DEFAULT, %i[]).tap do |out|
+      assert_includes out, '| a'
+      assert_includes out, '| <strong>x</strong>'
+      assert_includes out, '~~hi~~'
+    end
+
+    QiitaMarker.render_html(@markdown, :DEFAULT, %i[table]).tap do |out|
+      refute_includes out, '| a'
+      %w[<table> <tr> <th> a </th> <td> c </td> <strong>x</strong>].each { |html| assert_includes out, html }
+      assert_includes out, '~~hi~~'
+    end
+
+    QiitaMarker.render_html(@markdown, :DEFAULT, %i[strikethrough]).tap do |out|
+      assert_includes out, '| a'
+      refute_includes out, '~~hi~~'
+      assert_includes out, '<del>hi</del>'
+    end
+
+    doc = QiitaMarker.render_doc('~a~ ~~b~~ ~~~c~~~', :STRIKETHROUGH_DOUBLE_TILDE, [:strikethrough])
+    assert_equal("<p>~a~ <del>b</del> ~~~c~~~</p>\n", doc.to_html)
+
+    html = QiitaMarker.render_html('~a~ ~~b~~ ~~~c~~~', :STRIKETHROUGH_DOUBLE_TILDE, [:strikethrough])
+    assert_equal("<p>~a~ <del>b</del> ~~~c~~~</p>\n", html)
+
+    QiitaMarker.render_html(@markdown, :DEFAULT, %i[table strikethrough]).tap do |out|
+      refute_includes out, '| a'
+      refute_includes out, '| <strong>x</strong>'
+      refute_includes out, '~~hi~~'
+    end
+  end
+
+  def test_extensions_with_renderers
+    doc = QiitaMarker.render_doc(@markdown, :DEFAULT, %i[table])
+
+    doc.to_html.tap do |out|
+      refute_includes out, '| a'
+      %w[<table> <tr> <th> a </th> <td> c </td> <strong>x</strong>].each { |html| assert_includes out, html }
+      assert_includes out, '~~hi~~'
+    end
+
+    HtmlRenderer.new.render(doc).tap do |out|
+      refute_includes out, '| a'
+      %w[<table> <tr> <th> a </th> <td> c </td> <strong>x</strong>].each { |html| assert_includes out, html }
+      assert_includes out, '~~hi~~'
+    end
+
+    doc = QiitaMarker.render_doc('~a~ ~~b~~ ~~~c~~~', :STRIKETHROUGH_DOUBLE_TILDE, [:strikethrough])
+    assert_equal("<p>~a~ <del>b</del> ~~~c~~~</p>\n", HtmlRenderer.new.render(doc))
+  end
+
+  def test_bad_extension_specifications
+    assert_raises(TypeError) { QiitaMarker.render_html(@markdown, :DEFAULT, 'nope') }
+    assert_raises(TypeError) { QiitaMarker.render_html(@markdown, :DEFAULT, ['table']) }
+    assert_raises(ArgumentError) { QiitaMarker.render_html(@markdown, :DEFAULT, %i[table bad]) }
+  end
+
+  def test_comments_are_kept_as_expected
+    assert_equal "<!--hello--> <blah> &lt;xmp>\n",
+                 QiitaMarker.render_html("<!--hello--> <blah> <xmp>\n", :UNSAFE, %i[tagfilter])
+  end
+
+  def test_table_prefer_style_attributes
+    assert_equal(<<~HTML, QiitaMarker.render_html(<<~MD, :TABLE_PREFER_STYLE_ATTRIBUTES, %i[table]))
+      <table>
+      <thead>
+      <tr>
+      <th style="text-align: left">aaa</th>
+      <th>bbb</th>
+      <th style="text-align: center">ccc</th>
+      <th>ddd</th>
+      <th style="text-align: right">eee</th>
+      </tr>
+      </thead>
+      <tbody>
+      <tr>
+      <td style="text-align: left">fff</td>
+      <td>ggg</td>
+      <td style="text-align: center">hhh</td>
+      <td>iii</td>
+      <td style="text-align: right">jjj</td>
+      </tr>
+      </tbody>
+      </table>
+    HTML
+      aaa | bbb | ccc | ddd | eee
+      :-- | --- | :-: | --- | --:
+      fff | ggg | hhh | iii | jjj
+    MD
+  end
+
+  def test_plaintext
+    assert_equal(<<~HTML, QiitaMarker.render_doc(<<~MD, :DEFAULT, %i[table strikethrough]).to_plaintext)
+      Hello ~there~.
+
+      | a |
+      | --- |
+      | b |
+    HTML
+      Hello ~~there~~.
+
+      | a |
+      | - |
+      | b |
+    MD
+  end
+end

data/test/test_footnotes.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class TestFootnotes < Minitest::Test
+  def setup
+    @doc = QiitaMarker.render_doc("Hello[^hi].\n\n[^hi]: Hey!\n", :FOOTNOTES)
+  end
+
+  def test_to_html
+    expected = <<~HTML
+      <p>Hello<sup class="footnote-ref"><a href="#fn-hi" id="fnref-hi" data-footnote-ref>1</a></sup>.</p>
+      <section class="footnotes" data-footnotes>
+      <ol>
+      <li id="fn-hi">
+      <p>Hey! <a href="#fnref-hi" class="footnote-backref" data-footnote-backref aria-label="Back to content">↩</a></p>
+      </li>
+      </ol>
+      </section>
+    HTML
+
+    assert_equal expected, @doc.to_html
+  end
+
+  def test_html_renderer
+    expected = <<~HTML
+      <p>Hello<sup class="footnote-ref"><a href="#fn1" id="fnref1">1</a></sup>.</p>
+      <section class="footnotes">
+      <ol>
+      <li id="fn1">
+      <p>Hey! <a href="#fnref1" class="footnote-backref">↩</a></p>
+      </li>
+      </ol>
+      </section>
+    HTML
+
+    assert_equal expected, QiitaMarker::HtmlRenderer.new.render(@doc)
+  end
+
+  def test_render_html
+    md = <<~MARKDOWN
+      # footnotes
+      Let's render some footnotes[^1]
+
+      [^1]: This is a footnote
+    MARKDOWN
+    expected = <<~HTML
+      <h1>footnotes</h1>
+      <p>Let's render some footnotes<sup class="footnote-ref"><a href="#fn-1" id="fnref-1" data-footnote-ref>1</a></sup></p>
+      <section class="footnotes" data-footnotes>
+      <ol>
+      <li id="fn-1">
+      <p>This is a footnote <a href="#fnref-1" class="footnote-backref" data-footnote-backref aria-label="Back to content">↩</a></p>
+      </li>
+      </ol>
+      </section>
+    HTML
+    assert_equal expected, QiitaMarker.render_html(md, :FOOTNOTES)
+  end
+end

data/test/test_gc.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+# rubocop:disable Lint/UselessAssignment
+require 'test_helper'
+
+class TestNode < Minitest::Test
+  # These tests are somewhat fragile. It would be better to allocate lots
+  # of memory after a GC run to make sure that potentially freed memory
+  # isn't valid by accident.
+
+  def test_drop_parent_reference
+    doc = QiitaMarker.render_doc('Hi *there*')
+    text = doc.first_child.last_child.first_child
+    doc = nil
+    GC.start
+    # Test that doc has not been freed.
+    assert_equal 'there', text.string_content
+  end
+
+  def test_drop_child_reference
+    doc = QiitaMarker.render_doc('Hi *there*')
+    text = doc.first_child.last_child.first_child
+    text = nil
+    GC.start
+    # Test that the cached child object is still valid.
+    text = doc.first_child.last_child.first_child
+    assert_equal 'there', text.string_content
+  end
+
+  def test_remove_parent
+    doc = QiitaMarker.render_doc('Hi *there*')
+    para = doc.first_child
+    para.delete
+    doc = nil
+    para = nil
+    # TODO: Test that the `para` node was actually freed after unlinking.
+  end
+
+  def test_add_parent
+    doc = Node.new(:document)
+    hrule = Node.new(:hrule)
+    doc.append_child(hrule)
+    # If the hrule node was erroneously freed, this would result in a double
+    # free.
+  end
+end
+# rubocop:enable Lint/UselessAssignment

data/test/test_helper.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'qiita_marker'
+require 'minitest/autorun'
+require 'minitest/pride'
+require 'minitest/focus'
+
+include QiitaMarker # rubocop:disable Style/MixinUsage
+
+FIXTURES_DIR = File.join(File.dirname(__FILE__), 'fixtures')
+
+def fixtures_file(file)
+  File.read(File.join(FIXTURES_DIR, file), encoding: 'utf-8')
+end
+
+def make_bin(file, args = '')
+  `ruby bin/qiita_marker #{File.join(FIXTURES_DIR, file)} #{args}`.chomp
+end
+
+def open_spec_file(filename)
+  line_number = 0
+  start_line = 0
+  end_line = 0
+  example_number = 0
+  markdown_lines = []
+  html_lines = []
+  state = 0 # 0 regular text, 1 markdown example, 2 html output
+  headertext = ''
+  tests = []
+  extensions = []
+
+  header_re = Regexp.new('#+ ')
+  filepath = File.join('ext', 'qiita_marker', 'cmark-upstream', 'test', filename)
+
+  File.readlines(filepath, encoding: 'utf-8').each do |line|
+    line_number += 1
+
+    l = line.strip
+    if l =~ /^`{32} example(.*)$/
+      state = 1
+      extensions = Regexp.last_match(1).split
+    elsif l == '`' * 32
+      state = 0
+      example_number += 1
+      end_line = line_number
+      tests << {
+        markdown: markdown_lines.join.tr('→', "\t"),
+        html: html_lines.join.tr('→', "\t").rstrip,
+        example: example_number,
+        start_line: start_line,
+        end_line: end_line,
+        section: headertext,
+        extensions: extensions.map(&:to_sym)
+      }
+      start_line = 0
+      markdown_lines = []
+      html_lines = []
+    elsif l == '.'
+      state = 2
+    elsif state == 1
+      start_line = line_number - 1 if start_line.zero?
+      markdown_lines << line.to_s
+    elsif state == 2
+      html_lines << line.to_s
+    elsif state.zero? && header_re.match(line)
+      headertext = line.sub(header_re, '').strip
+    end
+  end
+
+  tests
+end

data/test/test_linebreaks.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class TestLinebreaks < Minitest::Test
+  def test_hardbreak_no_spaces
+    doc = QiitaMarker.render_doc("foo\nbaz")
+    assert_equal "<p>foo<br />\nbaz</p>\n", doc.to_html(:HARDBREAKS)
+  end
+
+  def test_hardbreak_with_spaces
+    doc = QiitaMarker.render_doc("foo  \nbaz")
+    assert_equal "<p>foo<br />\nbaz</p>\n", doc.to_html(:HARDBREAKS)
+  end
+end

data/test/test_maliciousness.rb

@@ -0,0 +1,262 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+module QiitaMarker
+  class TestMaliciousness < Minitest::Test
+    def setup
+      @doc = QiitaMarker.render_doc('Hi *there*')
+    end
+
+    def test_init_with_bad_type
+      assert_raises TypeError do
+        Node.new(123)
+      end
+
+      assert_raises NodeError do
+        Node.new(:totes_fake)
+      end
+
+      assert_raises TypeError do
+        Node.new([])
+      end
+
+      assert_raises TypeError do
+        Node.new([23])
+      end
+
+      assert_raises TypeError do
+        Node.new(nil)
+      end
+    end
+
+    def test_rendering_with_bad_type
+      assert_raises TypeError do
+        QiitaMarker.render_html("foo \n baz", 123)
+      end
+
+      assert_raises TypeError do
+        QiitaMarker.render_html("foo \n baz", :totes_fake)
+      end
+
+      assert_raises TypeError do
+        QiitaMarker.render_html("foo \n baz", [])
+      end
+
+      assert_raises TypeError do
+        QiitaMarker.render_html("foo \n baz", [23])
+      end
+
+      assert_raises TypeError do
+        QiitaMarker.render_html("foo \n baz", nil)
+      end
+
+      assert_raises TypeError do
+        QiitaMarker.render_html("foo \n baz", [:SMART, 'totes_fake'])
+      end
+
+      assert_raises TypeError do
+        QiitaMarker.render_html(123)
+      end
+
+      assert_raises TypeError do
+        QiitaMarker.render_html([123])
+      end
+
+      assert_raises TypeError do
+        QiitaMarker.render_html(nil)
+      end
+
+      assert_raises TypeError do
+        QiitaMarker.render_doc("foo \n baz", 123)
+      end
+
+      err = assert_raises TypeError do
+        QiitaMarker.render_doc("foo \n baz", :safe)
+      end
+      assert_equal('option \':safe\' does not exist for QiitaMarker::Config::OPTS[:parse]', err.message)
+
+      assert_raises TypeError do
+        QiitaMarker.render_doc("foo \n baz", :totes_fake)
+      end
+
+      assert_raises TypeError do
+        QiitaMarker.render_doc("foo \n baz", [])
+      end
+
+      assert_raises TypeError do
+        QiitaMarker.render_doc("foo \n baz", [23])
+      end
+
+      assert_raises TypeError do
+        QiitaMarker.render_doc("foo \n baz", nil)
+      end
+
+      assert_raises TypeError do
+        QiitaMarker.render_doc("foo \n baz", [:SMART, 'totes_fake'])
+      end
+
+      assert_raises TypeError do
+        QiitaMarker.render_doc(123)
+      end
+
+      assert_raises TypeError do
+        QiitaMarker.render_doc([123])
+      end
+
+      assert_raises TypeError do
+        QiitaMarker.render_doc(nil)
+      end
+    end
+
+    def test_bad_set_string_content
+      assert_raises TypeError do
+        @doc.string_content = 123
+      end
+    end
+
+    def test_bad_walking
+      assert_nil @doc.parent
+      assert_nil @doc.previous
+    end
+
+    def test_bad_insertion
+      code = Node.new(:code)
+      assert_raises NodeError do
+        @doc.insert_before(code)
+      end
+
+      paragraph = Node.new(:paragraph)
+      assert_raises NodeError do
+        @doc.insert_after(paragraph)
+      end
+
+      document = Node.new(:document)
+      assert_raises NodeError do
+        @doc.prepend_child(document)
+      end
+
+      assert_raises NodeError do
+        @doc.append_child(document)
+      end
+    end
+
+    def test_bad_url_get
+      assert_raises NodeError do
+        @doc.url
+      end
+    end
+
+    def test_bad_url_set
+      assert_raises NodeError do
+        @doc.url = '123'
+      end
+
+      link = QiitaMarker.render_doc('[GitHub](https://www.github.com)').first_child.first_child
+      assert_raises TypeError do
+        link.url = 123
+      end
+    end
+
+    def test_bad_title_get
+      assert_raises NodeError do
+        @doc.title
+      end
+    end
+
+    def test_bad_title_set
+      assert_raises NodeError do
+        @doc.title = '123'
+      end
+
+      image = QiitaMarker.render_doc('![alt text](https://github.com/favicon.ico "Favicon")')
+      image = image.first_child.first_child
+      assert_raises TypeError do
+        image.title = 123
+      end
+    end
+
+    def test_bad_header_level_get
+      assert_raises NodeError do
+        @doc.header_level
+      end
+    end
+
+    def test_bad_header_level_set
+      assert_raises NodeError do
+        @doc.header_level = 1
+      end
+
+      header = QiitaMarker.render_doc('### Header Three').first_child
+      assert_raises TypeError do
+        header.header_level = '123'
+      end
+    end
+
+    def test_bad_list_type_get
+      assert_raises NodeError do
+        @doc.list_type
+      end
+    end
+
+    def test_bad_list_type_set
+      assert_raises NodeError do
+        @doc.list_type = :bullet_list
+      end
+
+      ul_list = QiitaMarker.render_doc("* Bullet\n*Bullet").first_child
+      assert_raises NodeError do
+        ul_list.list_type = :fake
+      end
+      assert_raises TypeError do
+        ul_list.list_type = 1234
+      end
+    end
+
+    def test_bad_list_start_get
+      assert_raises NodeError do
+        @doc.list_start
+      end
+    end
+
+    def test_bad_list_start_set
+      assert_raises NodeError do
+        @doc.list_start = 12
+      end
+
+      ol_list = QiitaMarker.render_doc("1. One\n2. Two").first_child
+      assert_raises TypeError do
+        ol_list.list_start = :fake
+      end
+    end
+
+    def test_bad_list_tight_get
+      assert_raises NodeError do
+        @doc.list_tight
+      end
+    end
+
+    def test_bad_list_tight_set
+      assert_raises NodeError do
+        @doc.list_tight = false
+      end
+    end
+
+    def test_bad_fence_info_get
+      assert_raises NodeError do
+        @doc.fence_info
+      end
+    end
+
+    def test_bad_fence_info_set
+      assert_raises NodeError do
+        @doc.fence_info = 'ruby'
+      end
+
+      fence = QiitaMarker.render_doc("``` ruby\nputs 'wow'\n```").first_child
+      assert_raises TypeError do
+        fence.fence_info = 123
+      end
+    end
+  end
+end

data/test/test_node.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class TestNode < Minitest::Test
+  def setup
+    @doc = QiitaMarker.render_doc('Hi *there*, I am mostly text!')
+  end
+
+  def test_walk
+    nodes = []
+    @doc.walk do |node|
+      nodes << node.type
+    end
+    assert_equal %i[document paragraph text emph text text], nodes
+  end
+
+  def test_each
+    nodes = []
+    @doc.first_child.each do |node|
+      nodes << node.type
+    end
+    assert_equal %i[text emph text], nodes
+  end
+
+  def test_deprecated_each_child
+    nodes = []
+    _, err = capture_io do
+      @doc.first_child.each_child do |node|
+        nodes << node.type
+      end
+    end
+    assert_equal %i[text emph text], nodes
+    assert_match(/`each_child` is deprecated/, err)
+  end
+
+  def test_select
+    nodes = @doc.first_child.select { |node| node.type == :text }
+    assert_equal QiitaMarker::Node, nodes.first.class
+    assert_equal %i[text text], nodes.map(&:type)
+  end
+
+  def test_map
+    nodes = @doc.first_child.map(&:type)
+    assert_equal %i[text emph text], nodes
+  end
+
+  def test_insert_illegal
+    assert_raises NodeError do
+      @doc.insert_before(@doc)
+    end
+  end
+
+  def test_to_html
+    assert_equal "<p>Hi <em>there</em>, I am mostly text!</p>\n", @doc.to_html
+  end
+
+  def test_html_renderer
+    renderer = HtmlRenderer.new
+    result = renderer.render(@doc)
+    assert_equal "<p>Hi <em>there</em>, I am mostly text!</p>\n", result
+  end
+
+  def test_walk_and_set_string_content
+    @doc.walk do |node|
+      node.string_content = 'world' if node.type == :text && node.string_content == 'there'
+    end
+    result = HtmlRenderer.new.render(@doc)
+    assert_equal "<p>Hi <em>world</em>, I am mostly text!</p>\n", result
+  end
+
+  def test_walk_and_delete_node
+    @doc.walk do |node|
+      if node.type == :emph
+        node.insert_before(node.first_child)
+        node.delete
+      end
+    end
+    assert_equal "<p>Hi there, I am mostly text!</p>\n", @doc.to_html
+  end
+
+  def test_inspect
+    assert_match(/#<QiitaMarker::Node\(document\):/, @doc.inspect)
+  end
+
+  def test_pretty_print
+    assert_match(/#<QiitaMarker::Node\(document\):/, PP.pp(@doc, +''))
+  end
+end

data/test/test_options.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class TestExtensions < Minitest::Test
+  def test_full_info_string
+    md = <<~MD
+      ```ruby
+      module Foo
+      ```
+    MD
+
+    QiitaMarker.render_html(md, :FULL_INFO_STRING).tap do |out|
+      assert_includes out, '<pre><code class="language-ruby">'
+    end
+
+    md = <<~MD
+      ```ruby my info string
+      module Foo
+      ```
+    MD
+
+    QiitaMarker.render_html(md, :FULL_INFO_STRING).tap do |out|
+      assert_includes out, '<pre><code class="language-ruby" data-meta="my info string">'
+    end
+
+    md = <<~MD
+      ```ruby my \x00 string
+      module Foo
+      ```
+    MD
+
+    QiitaMarker.render_html(md, :FULL_INFO_STRING).tap do |out|
+      assert_includes out, %(<pre><code class="language-ruby" data-meta="my � string">)
+    end
+  end
+end