qiita_marker 0.23.2.1 → 0.23.5.0

data/test/test_linebreaks.rb

@@ -1,15 +0,0 @@
-# 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

@@ -1,262 +0,0 @@
-# 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

@@ -1,89 +0,0 @@
-# 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

@@ -1,37 +0,0 @@
-# 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

data/test/test_pathological_inputs.rb

@@ -1,94 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-require 'minitest/benchmark' if ENV['BENCH']
-
-def markdown(str)
-  QiitaMarker.render_doc(str).to_html
-end
-
-# list of pairs consisting of input and a regex that must match the output.
-pathological = {
-  'nested strong emph' =>
-              ["#{'*a **a ' * 65_000}b#{' a** a*' * 65_000}",
-               Regexp.compile('(<em>a <strong>a ){65_000}b( a</strong> a</em>){65_000}')],
-  'many emph closers with no openers' =>
-               [('a_ ' * 65_000),
-                Regexp.compile('(a[_] ){64999}a_')],
-  'many emph openers with no closers' =>
-               [('_a ' * 65_000),
-                Regexp.compile('(_a ){64999}_a')],
-  'many link closers with no openers' =>
-               [('a]' * 65_000),
-                Regexp.compile('(a\]){65_000}')],
-  'many link openers with no closers' =>
-               [('[a' * 65_000),
-                Regexp.compile('(\[a){65_000}')],
-  'mismatched openers and closers' =>
-               [('*a_ ' * 50_000),
-                Regexp.compile('([*]a[_] ){49999}[*]a_')],
-  'link openers and emph closers' =>
-               [('[ a_' * 50_000),
-                Regexp.compile('(\[ a_){50000}')],
-  'hard link/emph case' =>
-               ['**x [a*b**c*](d)',
-                Regexp.compile('\\*\\*x <a href=\'d\'>a<em>b</em><em>c</em></a>')],
-  'nested brackets' =>
-               ["#{'[' * 50_000}a#{']' * 50_000}",
-                Regexp.compile('\[{50000}a\]{50000}')],
-  'nested block quotes' =>
-               ["#{'> ' * 50_000}a",
-                Regexp.compile('(<blockquote>\n){50000}')],
-  'U+0000 in input' =>
-               ['abc\u0000de\u0000',
-                Regexp.compile('abc\ufffd?de\ufffd?')]
-}
-
-pathological.each_pair do |name, description|
-  define_method("test_#{name}") do
-    input, = description
-    assert markdown(input)
-  end
-end
-
-if ENV['BENCH']
-  class PathologicalInputsPerformanceTest < Minitest::Benchmark
-    def test_bench_pathological_one
-      assert_performance_linear 0.99 do |n|
-        star = '*' * (n * 10)
-        markdown("#{star}#{star}hi#{star}#{star}")
-      end
-    end
-
-    def test_bench_pathological_two
-      assert_performance_linear 0.99 do |n|
-        c = '`t`t`t`t`t`t' * (n * 10)
-        markdown(c)
-      end
-    end
-
-    def test_bench_pathological_three
-      assert_performance_linear 0.99 do |n|
-        markdown(" [a]: #{'A' * n}\n\n#{'[a][]' * n}\n")
-      end
-    end
-
-    def test_bench_pathological_four
-      assert_performance_linear 0.5 do |n|
-        markdown("#{'[' * n}a#{']' * n}")
-      end
-    end
-
-    def test_bench_pathological_five
-      assert_performance_linear 0.99 do |n|
-        markdown("#{'**a *a ' * n}#{'a* a**' * n}")
-      end
-    end
-
-    def test_bench_unbound_recursion
-      assert_performance_linear 0.99 do |n|
-        markdown("#{'[' * n}foo#{'](bar)' * n}")
-      end
-    end
-  end
-end

data/test/test_plaintext.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class TestPlaintext < Minitest::Test
-  def setup
-    @markdown = <<~MD
-      Hi *there*!
-
-      1. I am a numeric list.
-      2. I continue the list.
-      * Suddenly, an unordered list!
-      * What fun!
-
-      Okay, _enough_.
-
-      | a   | b   |
-      | --- | --- |
-      | c   | d   |
-    MD
-  end
-
-  def render_doc(doc)
-    QiitaMarker.render_doc(doc, :DEFAULT, %i[table])
-  end
-
-  def test_to_commonmark
-    compare = render_doc(@markdown).to_plaintext
-
-    assert_equal <<~PLAINTEXT, compare
-      Hi there!
-
-      1.  I am a numeric list.
-      2.  I continue the list.
-
-        - Suddenly, an unordered list!
-        - What fun!
-
-      Okay, enough.
-
-      | a | b |
-      | --- | --- |
-      | c | d |
-    PLAINTEXT
-  end
-end

data/test/test_qfm_code_data_metadata.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-require('test_helper')
-
-class TestQfmCodeDataMetadata < Minitest::Test
-  def setup
-    text = <<~MD
-      ```ruby:example.rb
-      puts :foo
-      ```
-    MD
-    @doc = QiitaMarker.render_doc(text, :DEFAULT, [])
-    @expected = <<~HTML
-      <pre><code data-metadata="ruby:example.rb">puts :foo
-      </code></pre>
-    HTML
-  end
-
-  def test_to_html
-    assert_equal(@expected, @doc.to_html(:CODE_DATA_METADATA))
-  end
-
-  def test_html_renderer
-    assert_equal(@expected, QiitaMarker::HtmlRenderer.new(options: :CODE_DATA_METADATA).render(@doc))
-  end
-end

data/test/test_qfm_custom_block.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-require('test_helper')
-
-class TestQfmCustomBlock < Minitest::Test
-  def setup
-    text = <<~MD
-      :::foo bar
-      message
-      :::
-    MD
-    @doc = QiitaMarker.render_doc(text, :DEFAULT, %i[custom_block])
-    @expected = <<~HTML
-      <div data-type="customblock" data-metadata="foo bar">
-      <p>message</p>
-      </div>
-    HTML
-  end
-
-  def test_to_html
-    assert_equal(@expected, @doc.to_html(:DEFAULT, %i[custom_block]))
-  end
-end

data/test/test_qfm_mention_no_emphasis.rb

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class TestQfmMentionNoEmphasis < Minitest::Test
-  describe 'with mention_no_emphasis option' do
-    [
-      ['@_username_',         false],
-      ['@__username__',       false],
-      ['@___username___',     false],
-      ['@user__name__',       false],
-      ['@some__user__name__', false],
-      [' @_username_',        false],
-      ['あ@_username_', false],
-      ['A@_username_',        true],
-      ['@*username*',         true],
-      ['_foo_',               true],
-      ['_',                   false],
-      ['_foo @username_',     false],
-      ['__foo @username__',   false],
-      ['___foo @username___', false]
-    ].each do |text, emphasize|
-      describe "with text #{text.inspect}" do
-        if emphasize
-          it 'emphasizes the text' do
-            QiitaMarker.render_html(text, :MENTION_NO_EMPHASIS).tap do |out|
-              assert_match(/(<em>|<strong>)/, out.chomp)
-            end
-          end
-        else
-          it 'does not emphasize the text' do
-            QiitaMarker.render_html(text, :MENTION_NO_EMPHASIS).tap do |out|
-              assert_match "<p>#{text.strip}</p>", out.chomp
-            end
-          end
-        end
-      end
-    end
-  end
-
-  describe 'without mention_no_emphasis option' do
-    describe 'with text "@_username_"' do
-      text = '@_username_'
-      it 'emphasizes the text' do
-        QiitaMarker.render_html(text, :DEFAULT, %i[]).tap do |out|
-          assert_match(/<em>/, out.chomp)
-        end
-      end
-    end
-
-    describe 'with text "_foo @username_"' do
-      text = '_foo @username_'
-      it 'emphasizes the text' do
-        QiitaMarker.render_html(text, :DEFAULT, %i[]).tap do |out|
-          assert_match(/<em>/, out.chomp)
-        end
-      end
-    end
-  end
-end

data/test/test_renderer.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class TestRenderer < Minitest::Test
-  def setup
-    @doc = QiitaMarker.render_doc('Hi *there*')
-  end
-
-  def test_html_renderer
-    renderer = HtmlRenderer.new
-    result = renderer.render(@doc)
-    assert_equal "<p>Hi <em>there</em></p>\n", result
-  end
-
-  def test_multiple_tables
-    content = <<~DOC
-      | Input       | Expected         | Actual    |
-      | ----------- | ---------------- | --------- |
-      | One         | Two              | Three     |
-
-      | Header   | Row  | Example |
-      | :------: | ---: | :------ |
-      | Foo      | Bar  | Baz     |
-    DOC
-    doc = QiitaMarker.render_doc(content, :DEFAULT, %i[autolink table tagfilter])
-    results = QiitaMarker::HtmlRenderer.new.render(doc)
-    assert_equal 2, results.scan(/<tbody>/).size
-  end
-
-  def test_escape_html_encoding
-    my_renderer = Class.new(HtmlRenderer) do
-      attr_reader :input_encoding, :output_encoding
-
-      def text(node)
-        @input_encoding = node.string_content.encoding
-        escape_html(node.string_content).tap do |escaped|
-          @output_encoding = escaped.encoding
-        end
-      end
-    end
-
-    renderer = my_renderer.new
-    assert_equal Encoding::UTF_8, renderer.render(@doc).encoding
-    assert_equal renderer.input_encoding, renderer.output_encoding
-  end
-end