1
0
Fork 0
mirror of https://github.com/ruby/ruby.git synced 2022-11-09 12:17:21 -05:00
ruby--ruby/test/rdoc/test_rdoc_markup_to_html.rb

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

961 lines
26 KiB
Ruby
Raw Normal View History

# frozen_string_literal: true
require_relative 'helper'
class TestRDocMarkupToHtml < RDoc::Markup::FormatterTestCase
add_visitor_tests
def setup
super
@to = RDoc::Markup::ToHtml.new @options
end
def accept_blank_line
assert_empty @to.res.join
end
def accept_block_quote
assert_equal "\n<blockquote>\n<p>quote</p>\n</blockquote>\n", @to.res.join
end
def accept_document
assert_equal "\n<p>hello</p>\n", @to.res.join
end
def accept_heading
links = '<span><a href="#label-Hello">&para;</a> ' +
'<a href="#top">&uarr;</a></span>'
expected = "\n<h5 id=\"label-Hello\">Hello#{links}</h5>\n"
assert_equal expected, @to.res.join
end
def accept_heading_1
links = '<span><a href="#label-Hello">&para;</a> ' +
'<a href="#top">&uarr;</a></span>'
assert_equal "\n<h1 id=\"label-Hello\">Hello#{links}</h1>\n", @to.res.join
end
def accept_heading_2
links = '<span><a href="#label-Hello">&para;</a> ' +
'<a href="#top">&uarr;</a></span>'
assert_equal "\n<h2 id=\"label-Hello\">Hello#{links}</h2>\n", @to.res.join
end
def accept_heading_3
links = '<span><a href="#label-Hello">&para;</a> ' +
'<a href="#top">&uarr;</a></span>'
assert_equal "\n<h3 id=\"label-Hello\">Hello#{links}</h3>\n", @to.res.join
end
def accept_heading_4
links = '<span><a href="#label-Hello">&para;</a> ' +
'<a href="#top">&uarr;</a></span>'
assert_equal "\n<h4 id=\"label-Hello\">Hello#{links}</h4>\n", @to.res.join
end
def accept_heading_b
links = '<span><a href="#label-Hello">&para;</a> ' +
'<a href="#top">&uarr;</a></span>'
inner = "<strong>Hello</strong>"
assert_equal "\n<h1 id=\"label-Hello\">#{inner}#{links}</h1>\n",
@to.res.join
end
def accept_heading_suppressed_crossref
links = '<span><a href="#label-Hello">&para;</a> ' +
'<a href="#top">&uarr;</a></span>'
assert_equal "\n<h1 id=\"label-Hello\">Hello#{links}</h1>\n", @to.res.join
end
def accept_list_end_bullet
assert_equal [], @to.list
assert_equal [], @to.in_list_entry
assert_equal "<ul></ul>\n", @to.res.join
end
def accept_list_end_label
assert_equal [], @to.list
assert_equal [], @to.in_list_entry
assert_equal "<dl class=\"rdoc-list label-list\"></dl>\n", @to.res.join
end
def accept_list_end_lalpha
assert_equal [], @to.list
assert_equal [], @to.in_list_entry
assert_equal "<ol style=\"list-style-type: lower-alpha\"></ol>\n", @to.res.join
end
def accept_list_end_number
assert_equal [], @to.list
assert_equal [], @to.in_list_entry
assert_equal "<ol></ol>\n", @to.res.join
end
def accept_list_end_note
assert_equal [], @to.list
assert_equal [], @to.in_list_entry
assert_equal "<dl class=\"rdoc-list note-list\"></dl>\n", @to.res.join
end
def accept_list_end_ualpha
assert_equal [], @to.list
assert_equal [], @to.in_list_entry
assert_equal "<ol style=\"list-style-type: upper-alpha\"></ol>\n", @to.res.join
end
def accept_list_item_end_bullet
assert_equal %w[</li>], @to.in_list_entry
end
def accept_list_item_end_label
assert_equal %w[</dd>], @to.in_list_entry
end
def accept_list_item_end_lalpha
assert_equal %w[</li>], @to.in_list_entry
end
def accept_list_item_end_note
assert_equal %w[</dd>], @to.in_list_entry
end
def accept_list_item_end_number
assert_equal %w[</li>], @to.in_list_entry
end
def accept_list_item_end_ualpha
assert_equal %w[</li>], @to.in_list_entry
end
def accept_list_item_start_bullet
assert_equal "<ul><li>", @to.res.join
end
def accept_list_item_start_label
assert_equal "<dl class=\"rdoc-list label-list\"><dt>cat\n<dd>", @to.res.join
end
def accept_list_item_start_lalpha
assert_equal "<ol style=\"list-style-type: lower-alpha\"><li>", @to.res.join
end
def accept_list_item_start_note
assert_equal "<dl class=\"rdoc-list note-list\"><dt>cat\n<dd>",
@to.res.join
end
def accept_list_item_start_note_2
expected = <<-EXPECTED
<dl class="rdoc-list note-list"><dt><code>teletype</code>
<dd>
<p>teletype description</p>
</dd></dl>
EXPECTED
assert_equal expected, @to.res.join
end
def accept_list_item_start_note_multi_description
expected = <<-EXPECTED
<dl class="rdoc-list note-list"><dt>label
<dd>
<p>description one</p>
</dd><dd>
<p>description two</p>
</dd></dl>
EXPECTED
assert_equal expected, @to.res.join
end
def accept_list_item_start_note_multi_label
expected = <<-EXPECTED
<dl class="rdoc-list note-list"><dt>one
<dt>two
<dd>
<p>two headers</p>
</dd></dl>
EXPECTED
assert_equal expected, @to.res.join
end
def accept_list_item_start_number
assert_equal "<ol><li>", @to.res.join
end
def accept_list_item_start_ualpha
assert_equal "<ol style=\"list-style-type: upper-alpha\"><li>", @to.res.join
end
def accept_list_start_bullet
assert_equal [:BULLET], @to.list
assert_equal [false], @to.in_list_entry
assert_equal "<ul>", @to.res.join
end
def accept_list_start_label
assert_equal [:LABEL], @to.list
assert_equal [false], @to.in_list_entry
assert_equal '<dl class="rdoc-list label-list">', @to.res.join
end
def accept_list_start_lalpha
assert_equal [:LALPHA], @to.list
assert_equal [false], @to.in_list_entry
assert_equal "<ol style=\"list-style-type: lower-alpha\">", @to.res.join
end
def accept_list_start_note
assert_equal [:NOTE], @to.list
assert_equal [false], @to.in_list_entry
assert_equal "<dl class=\"rdoc-list note-list\">", @to.res.join
end
def accept_list_start_number
assert_equal [:NUMBER], @to.list
assert_equal [false], @to.in_list_entry
assert_equal "<ol>", @to.res.join
end
def accept_list_start_ualpha
assert_equal [:UALPHA], @to.list
assert_equal [false], @to.in_list_entry
assert_equal "<ol style=\"list-style-type: upper-alpha\">", @to.res.join
end
def accept_paragraph
assert_equal "\n<p>hi</p>\n", @to.res.join
end
def accept_paragraph_b
assert_equal "\n<p>reg <strong>bold words</strong> reg</p>\n", @to.res.join
end
def accept_paragraph_br
assert_equal "\n<p>one<br>two</p>\n", @to.res.join
end
def accept_paragraph_break
assert_equal "\n<p>hello<br> world</p>\n", @to.res.join
end
def accept_paragraph_i
assert_equal "\n<p>reg <em>italic words</em> reg</p>\n", @to.res.join
end
def accept_paragraph_plus
assert_equal "\n<p>reg <code>teletype</code> reg</p>\n", @to.res.join
end
def accept_paragraph_star
assert_equal "\n<p>reg <strong>bold</strong> reg</p>\n", @to.res.join
end
def accept_paragraph_underscore
assert_equal "\n<p>reg <em>italic</em> reg</p>\n", @to.res.join
end
def accept_raw
raw = <<-RAW.rstrip
<table>
<tr><th>Name<th>Count
<tr><td>a<td>1
<tr><td>b<td>2
</table>
RAW
assert_equal raw, @to.res.join
end
def accept_rule
assert_equal "<hr>\n", @to.res.join
end
def accept_verbatim
assert_equal "\n<pre class=\"ruby\"><span class=\"ruby-identifier\">hi</span>\n <span class=\"ruby-identifier\">world</span>\n</pre>\n", @to.res.join
end
def end_accepting
assert_equal 'hi', @to.end_accepting
end
def start_accepting
assert_equal [], @to.res
assert_equal [], @to.in_list_entry
assert_equal [], @to.list
end
def list_nested
expected = <<-EXPECTED
<ul><li>
<p>l1</p>
<ul><li>
<p>l1.1</p>
</li></ul>
</li><li>
<p>l2</p>
</li></ul>
EXPECTED
assert_equal expected, @to.res.join
end
def list_verbatim
expected = <<-EXPECTED
<ul><li>
<p>list stuff</p>
<pre>* list
with
second
1. indented
2. numbered
third
* second</pre>
</li></ul>
EXPECTED
assert_equal expected, @to.end_accepting
end
def test_accept_heading_7
@to.start_accepting
@to.accept_heading @RM::Heading.new(7, 'Hello')
links = '<span><a href="#label-Hello">&para;</a> ' +
'<a href="#top">&uarr;</a></span>'
assert_equal "\n<h6 id=\"label-Hello\">Hello#{links}</h6>\n", @to.res.join
end
def test_accept_heading_aref_class
@to.code_object = RDoc::NormalClass.new 'Foo'
@to.start_accepting
@to.accept_heading head(1, 'Hello')
links = '<span><a href="#class-Foo-label-Hello">&para;</a> ' +
'<a href="#top">&uarr;</a></span>'
assert_equal "\n<h1 id=\"class-Foo-label-Hello\">Hello#{links}</h1>\n",
@to.res.join
end
def test_accept_heading_aref_method
@to.code_object = RDoc::AnyMethod.new nil, 'foo'
@to.start_accepting
@to.accept_heading @RM::Heading.new(1, 'Hello')
links = '<span><a href="#method-i-foo-label-Hello">&para;</a> ' +
'<a href="#top">&uarr;</a></span>'
assert_equal "\n<h1 id=\"method-i-foo-label-Hello\">Hello#{links}</h1>\n",
@to.res.join
end
def test_accept_heading_pipe
@options.pipe = true
@to.start_accepting
@to.accept_heading @RM::Heading.new(1, 'Hello')
assert_equal "\n<h1 id=\"label-Hello\">Hello</h1>\n", @to.res.join
end
def test_accept_paragraph_newline
@to.start_accepting
@to.accept_paragraph para("hello\n", "world\n")
assert_equal "\n<p>hello world </p>\n", @to.res.join
end
def test_accept_heading_output_decoration
@options.output_decoration = false
@to.start_accepting
@to.accept_heading @RM::Heading.new(1, 'Hello')
assert_equal "\n<h1>Hello<span><a href=\"#label-Hello\">&para;</a> <a href=\"#top\">&uarr;</a></span></h1>\n", @to.res.join
end
def test_accept_heading_output_decoration_with_pipe
@options.pipe = true
@options.output_decoration = false
@to.start_accepting
@to.accept_heading @RM::Heading.new(1, 'Hello')
assert_equal "\n<h1>Hello</h1>\n", @to.res.join
end
def test_accept_verbatim_parseable
verb = @RM::Verbatim.new("class C\n", "end\n")
@to.start_accepting
@to.accept_verbatim verb
expected = <<-EXPECTED
<pre class="ruby"><span class="ruby-keyword">class</span> <span class="ruby-constant">C</span>
<span class="ruby-keyword">end</span>
</pre>
EXPECTED
assert_equal expected, @to.res.join
end
def test_accept_verbatim_parseable_error
verb = @RM::Verbatim.new("a % 09 # => blah\n")
@to.start_accepting
@to.accept_verbatim verb
inner = CGI.escapeHTML "a % 09 # => blah"
expected = <<-EXPECTED
<pre>#{inner}</pre>
EXPECTED
assert_equal expected, @to.res.join
end
def test_accept_verbatim_nl_after_backslash
verb = @RM::Verbatim.new("a = 1 if first_flag_var and \\\n", " this_is_flag_var\n")
@to.start_accepting
@to.accept_verbatim verb
expected = <<-EXPECTED
<pre class="ruby"><span class="ruby-identifier">a</span> = <span class="ruby-value">1</span> <span class="ruby-keyword">if</span> <span class="ruby-identifier">first_flag_var</span> <span class="ruby-keyword">and</span> \\
<span class="ruby-identifier">this_is_flag_var</span>
</pre>
EXPECTED
assert_equal expected, @to.res.join
end
def test_accept_verbatim_pipe
@options.pipe = true
verb = @RM::Verbatim.new("1 + 1\n")
verb.format = :ruby
@to.start_accepting
@to.accept_verbatim verb
expected = <<-EXPECTED
<pre><code>1 + 1
</code></pre>
EXPECTED
assert_equal expected, @to.res.join
end
def test_accept_verbatim_escape_in_string
code = <<-'RUBY'
def foo
[
'\\',
'\'',
"'",
"\'\"\`",
"\#",
"\#{}",
"#",
"#{}",
/'"/,
/\'\"/,
/\//,
/\\/,
/\#/,
/\#{}/,
/#/,
/#{}/
]
end
def bar
end
RUBY
verb = @RM::Verbatim.new(*code.split(/(?<=\n)/))
@to.start_accepting
@to.accept_verbatim verb
expected = <<-'EXPECTED'
<pre class="ruby"><span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">foo</span>
[
<span class="ruby-string">&#39;\\&#39;</span>,
<span class="ruby-string">&#39;\&#39;&#39;</span>,
<span class="ruby-string">&quot;&#39;&quot;</span>,
<span class="ruby-string">&quot;\&#39;\&quot;\`&quot;</span>,
<span class="ruby-string">&quot;\#&quot;</span>,
<span class="ruby-string">&quot;\#{}&quot;</span>,
<span class="ruby-string">&quot;#&quot;</span>,
<span class="ruby-node">&quot;#{}&quot;</span>,
<span class="ruby-regexp">/&#39;&quot;/</span>,
<span class="ruby-regexp">/\&#39;\&quot;/</span>,
<span class="ruby-regexp">/\//</span>,
<span class="ruby-regexp">/\\/</span>,
<span class="ruby-regexp">/\#/</span>,
<span class="ruby-regexp">/\#{}/</span>,
<span class="ruby-regexp">/#/</span>,
<span class="ruby-regexp">/#{}/</span>
]
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">bar</span>
<span class="ruby-keyword">end</span>
</pre>
EXPECTED
assert_equal expected, @to.res.join
end
def test_accept_verbatim_escape_in_backtick
code = <<-'RUBY'
def foo
[
`\\`,
`\'\"\``,
`\#`,
`\#{}`,
`#`,
`#{}`
]
end
def bar
end
RUBY
verb = @RM::Verbatim.new(*code.split(/(?<=\n)/))
@to.start_accepting
@to.accept_verbatim verb
expected = <<-'EXPECTED'
<pre class="ruby"><span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">foo</span>
[
<span class="ruby-string">`\\`</span>,
<span class="ruby-string">`\&#39;\&quot;\``</span>,
<span class="ruby-string">`\#`</span>,
<span class="ruby-string">`\#{}`</span>,
<span class="ruby-string">`#`</span>,
<span class="ruby-node">`#{}`</span>
]
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">bar</span>
<span class="ruby-keyword">end</span>
</pre>
EXPECTED
assert_equal expected, @to.res.join
end
def test_accept_verbatim_ruby
verb = @RM::Verbatim.new("1 + 1\n")
verb.format = :ruby
@to.start_accepting
@to.accept_verbatim verb
expected = <<-EXPECTED
<pre class="ruby"><span class="ruby-value">1</span> <span class="ruby-operator">+</span> <span class="ruby-value">1</span>
</pre>
EXPECTED
assert_equal expected, @to.res.join
end
def test_accept_verbatim_redefinable_operators
functions = %w[| ^ & <=> == === =~ > >= < <= << >> + - * / % ** ~ +@ -@ [] []= ` ! != !~].map { |redefinable_op|
["def #{redefinable_op}\n", "end\n"]
}.flatten
verb = @RM::Verbatim.new(*functions)
@to.start_accepting
@to.accept_verbatim verb
expected = <<-EXPECTED
<pre class="ruby">
EXPECTED
expected = expected.rstrip
%w[| ^ &amp; &lt;=&gt; == === =~ &gt; &gt;= &lt; &lt;= &lt;&lt; &gt;&gt; + - * / % ** ~ +@ -@ [] []= ` ! != !~].each do |html_escaped_op|
expected += <<-EXPECTED
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">#{html_escaped_op}</span>
<span class="ruby-keyword">end</span>
EXPECTED
end
expected += <<-EXPECTED
</pre>
EXPECTED
assert_equal expected, @to.res.join
end
def test_convert_string
assert_equal '&lt;&gt;', @to.convert_string('<>')
end
def test_convert_HYPERLINK_irc
result = @to.convert 'irc://irc.freenode.net/#ruby-lang'
assert_equal "\n<p><a href=\"irc://irc.freenode.net/#ruby-lang\">irc.freenode.net/#ruby-lang</a></p>\n", result
end
def test_convert_RDOCLINK_label_label
result = @to.convert 'rdoc-label:label-One'
assert_equal "\n<p><a href=\"#label-One\">One</a></p>\n", result
end
def test_convert_RDOCLINK_label_foottext
result = @to.convert 'rdoc-label:foottext-1'
assert_equal "\n<p><a href=\"#foottext-1\">1</a></p>\n", result
end
def test_convert_RDOCLINK_label_footmark
result = @to.convert 'rdoc-label:footmark-1'
assert_equal "\n<p><a href=\"#footmark-1\">1</a></p>\n", result
end
def test_convert_RDOCLINK_ref
result = @to.convert 'rdoc-ref:C'
assert_equal "\n<p>C</p>\n", result
end
def test_convert_RDOCLINK_escape_image
assert_escaped '<script>', 'rdoc-image:"><script>alert(`rdoc-image`)</script>"'
end
def test_convert_RDOCLINK_escape_label_id
assert_escaped '<script>', 'rdoc-label::path::"><script>alert(`rdoc-label_id`)</script>"'
end
def test_convert_RDOCLINK_escape_label_path
assert_escaped '<script>', 'rdoc-label::"><script>alert(`rdoc-label_path`)</script>"'
end
def test_convert_RDOCLINK_escape_ref
assert_escaped '<script>', 'rdoc-ref:"><script>alert(`rdoc-ref`)</script>"'
end
def test_convert_RDOCLINK_escape_xxx
assert_escaped '<script>', 'rdoc-xxx:"><script>alert(`rdoc-xxx`)</script>"'
end
def test_convert_TIDYLINK_footnote
result = @to.convert 'text{*1}[rdoc-label:foottext-1:footmark-1]'
assert_equal "\n<p>text<sup><a id=\"footmark-1\" href=\"#foottext-1\">1</a></sup></p>\n", result
end
def test_convert_TIDYLINK_multiple
result = @to.convert '{a}[http://example] {b}[http://example]'
expected = <<-EXPECTED
<p><a href=\"http://example\">a</a> <a href=\"http://example\">b</a></p>
EXPECTED
assert_equal expected, result
end
def test_convert_TIDYLINK_image
result =
@to.convert '{rdoc-image:path/to/image.jpg}[http://example.com]'
expected =
"\n<p><a href=\"http://example.com\"><img src=\"path/to/image.jpg\"></a></p>\n"
assert_equal expected, result
result =
@to.convert '{rdoc-image:<script>alert`link text`</script>}[http://example.com]'
assert_not_include result, "<script>"
end
def test_convert_TIDYLINK_rdoc_label
result = @to.convert '{foo}[rdoc-label:foottext-1]'
assert_equal "\n<p><a href=\"#foottext-1\">foo</a></p>\n", result
end
def test_convert_TIDYLINK_irc
result = @to.convert '{ruby-lang}[irc://irc.freenode.net/#ruby-lang]'
assert_equal "\n<p><a href=\"irc://irc.freenode.net/#ruby-lang\">ruby-lang</a></p>\n", result
end
def test_convert_TIDYLINK_escape_text
assert_escaped '<script>', '{<script>alert`link text`</script>}[a]'
assert_escaped '<script>', 'x:/<script>alert(1);</script>[[]'
end
def test_convert_TIDYLINK_escape_javascript
assert_not_include '{click}[javascript:alert`javascript_scheme`]', '<a href="javascript:'
end
def test_convert_TIDYLINK_escape_onmouseover
assert_escaped '"/onmouseover="', '{onmouseover}[http://"/onmouseover="alert`on_mouse_link`"]'
end
def test_convert_TIDYLINK_escape_onerror
assert_escaped '"onerror="', '{link_image}[http://"onerror="alert`link_image`".png]'
end
def test_convert_with_exclude_tag
assert_equal "\n<p><code>aaa</code>[:symbol]</p>\n", @to.convert('+aaa+[:symbol]')
assert_equal "\n<p><code>aaa[:symbol]</code></p>\n", @to.convert('+aaa[:symbol]+')
assert_equal "\n<p><code>https:</code>-foobar</p>\n", @to.convert('<tt>https:</tt>-foobar')
assert_equal "\n<p><a href=\":symbol\">aaa</a></p>\n", @to.convert('aaa[:symbol]')
end
def test_convert_underscore_adjacent_to_code
assert_equal "\n<p><code>aaa</code>_</p>\n", @to.convert(%q{+aaa+_})
assert_equal "\n<p>\u{2018}<code>i386-mswin32_</code><em>MSRTVERSION</em>\u{2019}</p>\n", @to.convert(%q{`+i386-mswin32_+_MSRTVERSION_'})
end
def test_gen_url
assert_equal '<a href="example">example</a>',
@to.gen_url('link:example', 'example')
end
def test_gen_url_rdoc_label
assert_equal '<a href="#foottext-1">example</a>',
@to.gen_url('rdoc-label:foottext-1', 'example')
end
def test_gen_url_rdoc_label_id
assert_equal '<sup><a id="footmark-1" href="#foottext-1">example</a></sup>',
@to.gen_url('rdoc-label:foottext-1:footmark-1', 'example')
end
def test_gen_url_image_url
assert_equal '<img src="http://example.com/image.png" />', @to.gen_url('http://example.com/image.png', 'ignored')
end
def test_gen_url_ssl_image_url
assert_equal '<img src="https://example.com/image.png" />', @to.gen_url('https://example.com/image.png', 'ignored')
end
def test_gen_url_rdoc_file
assert_equal '<a href="example_rdoc.html">example</a>',
@to.gen_url('example.rdoc', 'example')
assert_equal '<a href="doc/example_rdoc.html">example</a>',
@to.gen_url('doc/example.rdoc', 'example')
assert_equal '<a href="../ex.doc/example_rdoc.html">example</a>',
@to.gen_url('../ex.doc/example.rdoc', 'example')
assert_equal '<a href="doc/example_rdoc.html#label-one">example</a>',
@to.gen_url('doc/example.rdoc#label-one', 'example')
assert_equal '<a href="../ex.doc/example_rdoc.html#label-two">example</a>',
@to.gen_url('../ex.doc/example.rdoc#label-two', 'example')
end
def test_gen_url_md_file
assert_equal '<a href="example_md.html">example</a>',
@to.gen_url('example.md', 'example')
assert_equal '<a href="doc/example_md.html">example</a>',
@to.gen_url('doc/example.md', 'example')
assert_equal '<a href="../ex.doc/example_md.html">example</a>',
@to.gen_url('../ex.doc/example.md', 'example')
assert_equal '<a href="doc/example_md.html#label-one">example</a>',
@to.gen_url('doc/example.md#label-one', 'example')
assert_equal '<a href="../ex.doc/example_md.html#label-two">example</a>',
@to.gen_url('../ex.doc/example.md#label-two', 'example')
end
def test_gen_url_rb_file
assert_equal '<a href="example_rb.html">example</a>',
@to.gen_url('example.rb', 'example')
assert_equal '<a href="doc/example_rb.html">example</a>',
@to.gen_url('doc/example.rb', 'example')
assert_equal '<a href="../ex.doc/example_rb.html">example</a>',
@to.gen_url('../ex.doc/example.rb', 'example')
assert_equal '<a href="doc/example_rb.html#label-one">example</a>',
@to.gen_url('doc/example.rb#label-one', 'example')
assert_equal '<a href="../ex.doc/example_rb.html#label-two">example</a>',
@to.gen_url('../ex.doc/example.rb#label-two', 'example')
end
def test_handle_regexp_HYPERLINK_link
target = RDoc::Markup::RegexpHandling.new 0, 'link:README.txt'
link = @to.handle_regexp_HYPERLINK target
assert_equal '<a href="README.txt">README.txt</a>', link
end
def test_handle_regexp_HYPERLINK_irc
target = RDoc::Markup::RegexpHandling.new 0, 'irc://irc.freenode.net/#ruby-lang'
link = @to.handle_regexp_HYPERLINK target
assert_equal '<a href="irc://irc.freenode.net/#ruby-lang">irc.freenode.net/#ruby-lang</a>', link
end
def test_handle_regexp_HYPERLINK_escape
code = 'irc://irc.freenode.net/"><script>alert(`irc`)</script><a"'
assert_escaped '<script>', code
end
def test_list_verbatim_2
str = "* one\n verb1\n verb2\n* two\n"
expected = <<-EXPECTED
<ul><li>
<p>one</p>
<pre class=\"ruby\"><span class=\"ruby-identifier\">verb1</span>
<span class=\"ruby-identifier\">verb2</span>
</pre>
</li><li>
<p>two</p>
</li></ul>
EXPECTED
assert_equal expected, @m.convert(str, @to)
end
def test_block_quote_in_verbatim
str = "BlockQuote\n >>>\n"
expected = <<-EXPECTED
<p>BlockQuote</p>
<pre>&gt;&gt;&gt;</pre>
EXPECTED
assert_equal expected, @m.convert(str, @to).gsub(/^\n/, "")
str = "BlockQuote\n >>> word\n"
expected = <<-EXPECTED
<p>BlockQuote</p>
<pre>&gt;&gt;&gt; word</pre>
EXPECTED
assert_equal expected, @m.convert(str, @to).gsub(/^\n/, "")
end
def test_parseable_eh
valid_syntax = [
'def x() end',
'def x; end',
'class C; end',
"module M end",
'a # => blah',
'x { |y| nil }',
'x do |y| nil end',
'# only a comment',
'require "foo"',
'cls="foo"'
]
invalid_syntax = [
'def x end',
'class C < end',
'module M < C end',
'a=># blah',
'x { |y| ... }',
'x do |y| ... end',
'// only a comment',
'<% require "foo" %>',
'class="foo"'
]
valid_syntax.each do |t|
assert @to.parseable?(t), "valid syntax considered invalid: #{t}"
end
invalid_syntax.each do |t|
refute @to.parseable?(t), "invalid syntax considered valid: #{t}"
end
end
def test_to_html
assert_equal "\n<p><code>--</code></p>\n", util_format("<tt>--</tt>")
end
def util_format text
paragraph = RDoc::Markup::Paragraph.new text
@to.start_accepting
@to.accept_paragraph paragraph
@to.end_accepting
end
def test_accept_table
header = %w[Col1 Col2 Col3]
body = [
%w[cell1_1 cell1_2 cell1_3],
%w[cell2_1 cell2_2 cell2_3],
['<script>alert("foo");</script>',],
%w[+code+ _em_ **strong**],
]
aligns = [:left, :right, nil]
@to.start_accepting
@to.accept_table(header, body, aligns)
res = @to.end_accepting
assert_include(res[%r<<th[^<>]*>Col1</th>>], 'align="left"')
assert_include(res[%r<<th[^<>]*>Col2</th>>], 'align="right"')
assert_not_include(res[%r<<th[^<>]*>Col3</th>>], 'align=')
assert_include(res[%r<<td[^<>]*>cell1_1</td>>], 'align="left"')
assert_include(res[%r<<td[^<>]*>cell1_2</td>>], 'align="right"')
assert_not_include(res[%r<<td[^<>]*>cell1_3</td>>], 'align=')
assert_include(res[%r<<td[^<>]*>cell2_1</td>>], 'align="left"')
assert_include(res[%r<<td[^<>]*>cell2_2</td>>], 'align="right"')
assert_not_include(res[%r<<td[^<>]*>cell2_3</td>>], 'align=')
assert_not_include(res, '<script>')
assert_include(res[%r<<td[^<>]*>.*script.*</td>>], '&lt;script&gt;')
assert_include(res[%r<<td[^<>]*>.*code.*</td>>], '<code>code</code>')
assert_include(res[%r<<td[^<>]*>.*em.*</td>>], '<em>em</em>')
assert_include(res[%r<<td[^<>]*>.*strong.*</td>>], '<strong>strong</strong>')
end
def assert_escaped(unexpected, code)
result = @to.convert(code)
assert_not_include result, unexpected
assert_include result, CGI.escapeHTML(unexpected)
end
end