Class: RDoc::Markup::ToHtml

Inherits:
Markup::Formatter
  • Object
show all
Includes:
Text
Defined in:
lib/rdoc/markup/to_html.rb

Overview

Outputs RDoc markup as HTML.

Defined Under Namespace

Classes: QuoteConverter

Constant Summary collapse

LIST_TYPE_TO_HTML =

Maps RDoc::Markup::Parser::LIST_TOKENS types to HTML tags

{
  :BULLET => ['<ul>',                                      '</ul>'],
  :LABEL  => ['<dl class="rdoc-list label-list">',         '</dl>'],
  :LALPHA => ['<ol style="list-style-type: lower-alpha">', '</ol>'],
  :NOTE   => ['<dl class="rdoc-list note-list">',          '</dl>'],
  :NUMBER => ['<ol>',                                      '</ol>'],
  :UALPHA => ['<ol style="list-style-type: upper-alpha">', '</ol>'],
}
TO_HTML_CHARACTERS =

Maps an encoding to a Hash of characters properly transcoded for that encoding.

See also encode_fallback.

Hash.new do |h, encoding|
  h[encoding] = {
    close_dquote: encode_fallback('”', encoding, '"'),
    close_squote: encode_fallback('’', encoding, '\''),
    copyright:    encode_fallback('©', encoding, '(c)'),
    ellipsis:     encode_fallback('…', encoding, '...'),
    dot_ellipsis: encode_fallback('.…', encoding, '....'),
    em_dash:      encode_fallback('—', encoding, '---'),
    en_dash:      encode_fallback('–', encoding, '--'),
    open_dquote:  encode_fallback('“', encoding, '"'),
    open_squote:  encode_fallback('‘', encoding, '\''),
    trademark:    encode_fallback('®', encoding, '(r)'),
  }
end
HTML_CHARACTER_ALIASES = 
{
  '(c)' => :copyright,
  '(C)' => :copyright,
  '(r)' => :trademark,
  '(R)' => :trademark,
  '---' => :em_dash,
  '--'  => :en_dash,
  '....' => :dot_ellipsis,
  '...' => :ellipsis,
  '``' => :open_dquote,
  "''" => :close_dquote,
}
HTML_CHARACTERS_REGEXP = 
Regexp.union(HTML_CHARACTER_ALIASES.keys)
UNSAFE_URL_SCHEME_REGEXP =

URL schemes that are not linked because they can run scripts or open local files. Links to them are rendered as their text only.

/\A(?:javascript|vbscript|data|file):/i
URL_CHARACTERS_REGEXP_STR =

:nodoc:

/[A-Za-z0-9\-._~:\/\?#\[\]@!$&'\(\)*+,;%=]/.source

Constants included from Text

Text::MARKUP_FORMAT, Text::SPACE_SEPARATED_LETTER_CLASS

Instance Attribute Summary collapse

Attributes included from Text

#language

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Text

decode_legacy_label, expand_tabs, #flush_left, #markup, #normalize_comment, #parse, #snippet, #strip_hashes, #strip_newlines, #strip_stars, to_anchor, #wrap

Constructor Details

#initialize(pipe: false, output_decoration: true) ⇒ ToHtml

Creates a new formatter that will output HTML



130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
 
# File 'lib/rdoc/markup/to_html.rb', line 130

def initialize(pipe: false, output_decoration: true)
  super()

  @pipe = pipe
  @output_decoration = output_decoration
  @code_object = nil
  @from_path = ''
  @in_list_entry = nil
  @list = nil
  @th = nil
  @quote_converter = nil
  @in_tidylink_label = false
  @hard_break = "<br>\n"

  init_regexp_handlings
end

Instance Attribute Details

#code_object ⇒ Object

The RDoc::CodeObject HTML is being generated for. This is used to generate namespaced URI fragments



37
38
39
 
# File 'lib/rdoc/markup/to_html.rb', line 37

def code_object
  @code_object
end

#from_path ⇒ Object

Path to this document for relative links



42
43
44
 
# File 'lib/rdoc/markup/to_html.rb', line 42

def from_path
  @from_path
end

#in_list_entry ⇒ Object (readonly)

:nodoc:



30
31
32
 
# File 'lib/rdoc/markup/to_html.rb', line 30

def in_list_entry
  @in_list_entry
end

#list ⇒ Object (readonly)

:nodoc:



31
32
33
 
# File 'lib/rdoc/markup/to_html.rb', line 31

def list
  @list
end

#res ⇒ Object (readonly)

:nodoc:



29
30
31
 
# File 'lib/rdoc/markup/to_html.rb', line 29

def res
  @res
end

Class Method Details

.encode_fallback(character, encoding, fallback) ⇒ Object

Transcodes character to encoding with a fallback character.



82
83
84
85
86
87
88
89
 
# File 'lib/rdoc/markup/to_html.rb', line 82

def self.encode_fallback(character, encoding, fallback)
  character.encode(
    encoding,
    fallback: { character => fallback },
    undef: :replace,
    replace: fallback
  )
end

Instance Method Details

#accept_blank_line(blank_line) ⇒ Object

Adds blank_line to the output



518
519
520
 
# File 'lib/rdoc/markup/to_html.rb', line 518

def accept_blank_line(blank_line)
  # @res << annotate("<p />") << "\n"
end

#accept_block_quote(block_quote) ⇒ Object

Adds block_quote to the output



412
413
414
415
416
417
418
419
420
 
# File 'lib/rdoc/markup/to_html.rb', line 412

def accept_block_quote(block_quote)
  @res << "\n<blockquote>"

  block_quote.parts.each do |part|
    part.accept self
  end

  @res << "</blockquote>\n"
end

#accept_heading(heading) ⇒ Object

Adds heading to the output. The headings greater than 6 are trimmed to level 6.



526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
 
# File 'lib/rdoc/markup/to_html.rb', line 526

def accept_heading(heading)
  level = [6, heading.level].min

  label = deduplicate_heading_id(heading.label(@code_object))
  legacy_label = deduplicate_heading_id(heading.legacy_label(@code_object))

  # Add legacy anchor before the heading for backward compatibility.
  # This allows old links with label- prefix to still work.
  if @output_decoration && !@pipe
    @res << "\n<span id=\"#{legacy_label}\" class=\"legacy-anchor\"></span>"
  end

  @res << if @output_decoration
            "\n<h#{level} id=\"#{label}\">"
          else
            "\n<h#{level}>"
          end

  if @pipe
    @res << to_html(heading.text)
  else
    @res << "<a href=\"##{label}\">#{to_html(heading.text)}</a>"
  end

  @res << "</h#{level}>\n"
end

#accept_list_end(list) ⇒ Object

Finishes consumption of list



489
490
491
492
493
494
495
 
# File 'lib/rdoc/markup/to_html.rb', line 489

def accept_list_end(list)
  @list.pop
  if tag = @in_list_entry.pop
    @res << tag
  end
  @res << html_list_name(list.type, false) << "\n"
end

#accept_list_item_end(list_item) ⇒ Object

Finishes consumption of list_item



511
512
513
 
# File 'lib/rdoc/markup/to_html.rb', line 511

def accept_list_item_end(list_item)
  @in_list_entry[-1] = list_end_for(@list.last)
end

#accept_list_item_start(list_item) ⇒ Object

Prepares the visitor for consuming list_item



500
501
502
503
504
505
506
 
# File 'lib/rdoc/markup/to_html.rb', line 500

def accept_list_item_start(list_item)
  if tag = @in_list_entry.last
    @res << tag
  end

  @res << list_item_start(list_item, @list.last)
end

#accept_list_start(list) ⇒ Object

Prepares the visitor for consuming list



480
481
482
483
484
 
# File 'lib/rdoc/markup/to_html.rb', line 480

def accept_list_start(list)
  @list << list.type
  @res << html_list_name(list.type, true)
  @in_list_entry.push false
end

#accept_paragraph(paragraph) ⇒ Object

Adds paragraph to the output



425
426
427
428
429
430
431
432
433
 
# File 'lib/rdoc/markup/to_html.rb', line 425

def accept_paragraph(paragraph)
  @res << "\n<p>"
  text = paragraph.text @hard_break
  text = text.gsub(/(#{SPACE_SEPARATED_LETTER_CLASS})?\K(?:\r?\n)+(?=(?(1)(#{SPACE_SEPARATED_LETTER_CLASS})?))/o) {
    defined?($2) && ' '
  }
  @res << to_html(text)
  @res << "</p>\n"
end

#accept_raw(raw) ⇒ Object

Adds raw to the output



556
557
558
 
# File 'lib/rdoc/markup/to_html.rb', line 556

def accept_raw(raw)
  @res << raw.parts.join("\n")
end

#accept_rule(rule) ⇒ Object

Adds rule to the output



473
474
475
 
# File 'lib/rdoc/markup/to_html.rb', line 473

def accept_rule(rule)
  @res << "<hr>\n"
end

#accept_table(header, body, aligns) ⇒ Object

Adds table to the output



563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
 
# File 'lib/rdoc/markup/to_html.rb', line 563

def accept_table(header, body, aligns)
  @res << "\n<table role=\"table\">\n<thead>\n<tr>\n"
  header.zip(aligns) do |text, align|
    @res << '<th'
    @res << ' align="' << align << '"' if align
    @res << '>' << to_html(text) << "</th>\n"
  end
  @res << "</tr>\n</thead>\n<tbody>\n"
  body.each do |row|
    @res << "<tr>\n"
    row.zip(aligns) do |text, align|
      @res << '<td'
      @res << ' align="' << align << '"' if align
      @res << '>' << to_html(text) << "</td>\n"
    end
    @res << "</tr>\n"
  end
  @res << "</tbody>\n</table>\n"
end

#accept_verbatim(verbatim) ⇒ Object

Adds verbatim to the output



447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
 
# File 'lib/rdoc/markup/to_html.rb', line 447

def accept_verbatim(verbatim)
  text = verbatim.text.rstrip
  format = verbatim.format

  # Apply Ruby syntax highlighting if
  # - explicitly marked as Ruby (via ruby? which accepts :ruby or :rb)
  # - no format specified but the text is parseable as Ruby
  # Otherwise, add language class when applicable and skip Ruby highlighting
  if verbatim.ruby? || (format.nil? && parseable?(text))
    content = parsable_text_to_html(text)
    klass = ' class="ruby"'
  else
    content = CGI.escapeHTML text
    klass = " class=\"#{format}\"" if format
  end

  if @pipe
    @res << "\n<pre><code>#{CGI.escapeHTML text}\n</code></pre>\n"
  else
    @res << "\n<pre#{klass}>#{content}</pre>\n"
  end
end

#apply_tidylink_label_special_handling(label, url) ⇒ Object

Special handling for tidy link labels. When a tidy link is rdoc-image:path/to/image.jpg:alt text, label part is normally considered RDOCLINK rdoc-image:path/to/image.jpg:alt and a text " text" but RDoc's test code expects the whole label part to be treated as RDOCLINK only in tidy link label. When a tidy link is ^1 or *1, the label part needs to drop leading * or ^. TODO: reconsider this workaround.



282
283
284
285
286
287
288
 
# File 'lib/rdoc/markup/to_html.rb', line 282

def apply_tidylink_label_special_handling(label, url)
  # ^1 *1 will be converted to just 1 in tidy link label.
  return label[1..] if label.match?(/\A[*^]\d+\z/)

  # rdoc-image in label specially allows spaces in alt text.
  return handle_RDOCLINK(label) if label.start_with?('rdoc-image:')
end

#convert_string(text) ⇒ Object

CGI-escapes text



602
603
604
 
# File 'lib/rdoc/markup/to_html.rb', line 602

def convert_string(text)
  CGI.escapeHTML text
end

#deduplicate_heading_id(id) ⇒ Object

Returns a unique heading ID, appending -1, -2, etc. for duplicates. Matches GitHub's behavior for duplicate heading anchors.



589
590
591
592
593
594
595
596
597
 
# File 'lib/rdoc/markup/to_html.rb', line 589

def deduplicate_heading_id(id)
  if @heading_ids.key?(id)
    @heading_ids[id] += 1
    "#{id}-#{@heading_ids[id]}"
  else
    @heading_ids[id] = 0
    id
  end
end

#emit_inline(text) ⇒ Object 



265
266
267
 
# File 'lib/rdoc/markup/to_html.rb', line 265

def emit_inline(text)
  @inline_output << text
end

#end_accepting ⇒ Object

Returns the generated output



405
406
407
 
# File 'lib/rdoc/markup/to_html.rb', line 405

def end_accepting
  @res.join
end

#gen_url(url, text) ⇒ Object

Generates an HTML link or image tag for the given url and text.

  • Image URLs (http/https/link ending in .gif, .png, .jpg, .jpeg, .bmp) become tags
  • File references (.rb, .rdoc, .md) are converted to .html paths
  • Anchor URLs (#foo) pass through unchanged for GitHub-style header linking
  • Footnote links get wrapped in tags
  • URLs with an unsafe scheme (javascript:, vbscript:, data:, file:) are not linked and only text is returned


617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
 
# File 'lib/rdoc/markup/to_html.rb', line 617

def gen_url(url, text)
  scheme, url, id = parse_url url

  # Check the parsed URL because link: URLs are used as href without it
  return text if unsafe_url?(url)

  if %w[http https link].include?(scheme) && url =~ /\.(gif|png|jpg|jpeg|bmp)\z/
    "<img src=\"#{url}\" />"
  else
    if scheme != 'link' and %r%\A((?!https?:)(?:[^/#]*/)*+)([^/#]+)\.(rb|rdoc|md)(?=\z|#)%i =~ url
      url = "#$1#{$2.tr('.', '_')}_#$3.html#$'"
    end

    text = text.sub %r%^#{scheme}:/*%i, ''
    text = text.sub %r%^[*\^](\d+)$%,   '\1'

    link = "<a#{id} href=\"#{url}\">#{text}</a>"

    if /"foot/.match?(id)
      "<sup>#{link}</sup>"
    else
      link
    end
  end
end

#handle_BOLD(nodes) ⇒ Object 



225
226
227
228
229
 
# File 'lib/rdoc/markup/to_html.rb', line 225

def handle_BOLD(nodes)
  emit_inline('<strong>')
  super
  emit_inline('</strong>')
end

#handle_BOLD_WORD(word) ⇒ Object 



237
238
239
240
241
 
# File 'lib/rdoc/markup/to_html.rb', line 237

def handle_BOLD_WORD(word)
  emit_inline('<strong>')
  super
  emit_inline('</strong>')
end

#handle_EM(nodes) ⇒ Object 



231
232
233
234
235
 
# File 'lib/rdoc/markup/to_html.rb', line 231

def handle_EM(nodes)
  emit_inline('<em>')
  super
  emit_inline('</em>')
end

#handle_EM_WORD(word) ⇒ Object 



243
244
245
246
247
 
# File 'lib/rdoc/markup/to_html.rb', line 243

def handle_EM_WORD(word)
  emit_inline('<em>')
  super
  emit_inline('</em>')
end

#handle_HARD_BREAK ⇒ Object 



261
262
263
 
# File 'lib/rdoc/markup/to_html.rb', line 261

def handle_HARD_BREAK
  emit_inline('<br>')
end

#handle_inline(text) ⇒ Object

:nodoc:



326
327
328
329
330
331
332
333
334
 
# File 'lib/rdoc/markup/to_html.rb', line 326

def handle_inline(text) # :nodoc:
  @inline_output = +''
  @quote_converter = QuoteConverter.new
  super
  out = @inline_output
  @inline_output = nil
  @quote_converter = nil
  out
end

#handle_PLAIN_TEXT(text) ⇒ Object 



217
218
219
 
# File 'lib/rdoc/markup/to_html.rb', line 217

def handle_PLAIN_TEXT(text)
  emit_inline(convert_string(text))
end

#handle_RDOCLINK(url) ⇒ Object

:nodoc:



186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
 
# File 'lib/rdoc/markup/to_html.rb', line 186

def handle_RDOCLINK(url) # :nodoc:
  case url
  when /^rdoc-ref:/
    CGI.escapeHTML($')
  when /^rdoc-label:/
    return CGI.escapeHTML(url) if in_tidylink_label?
    text = $'

    text = case text
           when /\Alabel-/    then $'
           when /\Afootmark-/ then $'
           when /\Afoottext-/ then $'
           else                    text
           end

    gen_url CGI.escapeHTML(url), CGI.escapeHTML(text)
  when /^rdoc-image:/
    # Split the string after "rdoc-image:" into url and alt.
    #   "path/to/image.jpg:alt text" => ["path/to/image.jpg", "alt text"]
    #   "http://example.com/path/to/image.jpg:alt text" => ["http://example.com/path/to/image.jpg", "alt text"]
    url, alt = $'.split(/:(?!\/)/, 2)
    if alt && !alt.empty?
      %[<img src="#{CGI.escapeHTML(url)}" alt="#{CGI.escapeHTML(alt)}">]
    else
      %[<img src="#{CGI.escapeHTML(url)}">]
    end
  when /\Ardoc-[a-z]+:/
    CGI.escapeHTML($')
  end
end

#handle_REGEXP_HANDLING_TEXT(text) ⇒ Object 



221
222
223
 
# File 'lib/rdoc/markup/to_html.rb', line 221

def handle_REGEXP_HANDLING_TEXT(text)
  emit_inline(text)
end

#handle_regexp_HTML_CHARACTERS(text) ⇒ Object

Converts (c), (r), --, --- , ..., ...., ``, '' to HTML characters.



337
338
339
340
 
# File 'lib/rdoc/markup/to_html.rb', line 337

def handle_regexp_HTML_CHARACTERS(text)
  name = HTML_CHARACTER_ALIASES[text]
  TO_HTML_CHARACTERS[text.encoding][name] if name
end

#handle_regexp_HYPERLINK(text) ⇒ Object

target is a potential link. The following schemes are handled:

mailto:::

Inserted as-is.

http:::

Links are checked to see if they reference an image. If so, that image
gets inserted using an <tt><img></tt> tag. Otherwise a conventional
<tt><a href></tt> is used.

link:::

Reference to a local file relative to the output directory.



368
369
370
371
372
373
 
# File 'lib/rdoc/markup/to_html.rb', line 368

def handle_regexp_HYPERLINK(text)
  return convert_string(text) if in_tidylink_label?

  url = CGI.escapeHTML(text)
  gen_url url, url
end

#handle_regexp_QUOTE_AFTER_WORD(text) ⇒ Object 



346
347
348
 
# File 'lib/rdoc/markup/to_html.rb', line 346

def handle_regexp_QUOTE_AFTER_WORD(text)
  @quote_converter.convert(text, after_word: true) || convert_string(text)
end

#handle_regexp_QUOTE_NOT_AFTER_WORD(text) ⇒ Object 



342
343
344
 
# File 'lib/rdoc/markup/to_html.rb', line 342

def handle_regexp_QUOTE_NOT_AFTER_WORD(text)
  @quote_converter.convert(text, after_word: false) || convert_string(text)
end

#handle_regexp_RDOCLINK(text) ⇒ Object

target is an rdoc-schemed link that will be converted into a hyperlink.

For the rdoc-ref scheme the named reference will be returned without creating a link.

For the rdoc-label scheme the footnote and label prefixes are stripped when creating a link. All other contents will be linked verbatim.



384
385
386
 
# File 'lib/rdoc/markup/to_html.rb', line 384

def handle_regexp_RDOCLINK(text)
  handle_RDOCLINK text
end

#handle_regexp_SUPPRESSED_CROSSREF(text) ⇒ Object

Converts suppressed cross-reference text to HTML by removing the leading backslash.



352
353
354
 
# File 'lib/rdoc/markup/to_html.rb', line 352

def handle_regexp_SUPPRESSED_CROSSREF(text)
  convert_string(text.delete_prefix('\\'))
end

#handle_STRIKE(nodes) ⇒ Object 



255
256
257
258
259
 
# File 'lib/rdoc/markup/to_html.rb', line 255

def handle_STRIKE(nodes)
  emit_inline('<del>')
  super
  emit_inline('</del>')
end

#handle_TIDYLINK(label_part, url) ⇒ Object 



290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
 
# File 'lib/rdoc/markup/to_html.rb', line 290

def handle_TIDYLINK(label_part, url)
  # When url is an image, ignore label part (maybe bug?) and just generate img tag.
  if url.match?(/\Ahttps?:\/\/.+\.(png|gif|jpg|jpeg|bmp)\z/)
    emit_inline("<img src=\"#{CGI.escapeHTML(url)}\" />")
    return
  elsif url.match?(/\Ardoc-image:/)
    emit_inline(handle_RDOCLINK(url))
    return
  end

  if label_part.size == 1 && String === label_part[0]
    raw_label = label_part[0]

    @in_tidylink_label = true
    special = apply_tidylink_label_special_handling(raw_label, url)
    @in_tidylink_label = false

    if special
      tag = gen_url(CGI.escapeHTML(url), special)
      unless tag.empty?
        emit_inline(tag)
        return
      end
    end
  end

  tag = gen_url(CGI.escapeHTML(url), '')
  open_tag, close_tag = tag.split(/(?=<\/a>)/, 2)
  valid_tag = open_tag && close_tag
  emit_inline(open_tag) if valid_tag
  @in_tidylink_label = true
  traverse_inline_nodes(label_part)
  @in_tidylink_label = false
  emit_inline(close_tag) if valid_tag
end

#handle_TT(code) ⇒ Object 



249
250
251
252
253
 
# File 'lib/rdoc/markup/to_html.rb', line 249

def handle_TT(code)
  emit_inline('<code>')
  super
  emit_inline('</code>')
end

#html_list_name(list_type, open_tag) ⇒ Object

Determines the HTML list element for list_type and open_tag

Raises:



659
660
661
662
663
 
# File 'lib/rdoc/markup/to_html.rb', line 659

def html_list_name(list_type, open_tag)
  tags = LIST_TYPE_TO_HTML[list_type]
  raise Error, "Invalid list type: #{list_type.inspect}" unless tags
  tags[open_tag ? 0 : 1]
end

#in_tidylink_label? ⇒ Boolean

Returns true if we are processing inside a tidy link label.

Returns:

  • (Boolean) 


271
272
273
 
# File 'lib/rdoc/markup/to_html.rb', line 271

def in_tidylink_label?
  @in_tidylink_label
end

#init_link_notation_regexp_handlings ⇒ Object

Adds regexp handlings about link notations.



182
183
184
 
# File 'lib/rdoc/markup/to_html.rb', line 182

def init_link_notation_regexp_handlings
  add_regexp_handling_RDOCLINK
end

#init_regexp_handlings ⇒ Object

Adds regexp handlings.



163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
 
# File 'lib/rdoc/markup/to_html.rb', line 163

def init_regexp_handlings
  # external links
  @markup.add_regexp_handling(/(?:link:|https?:|mailto:|ftp:|irc:|www\.)#{URL_CHARACTERS_REGEXP_STR}+\w/o,
                              :HYPERLINK)

  # suppress crossref: \#method \::method \ClassName \method_with_underscores
  @markup.add_regexp_handling(/\\(?:[#:A-Z]|[a-z]+_[a-z0-9])/, :SUPPRESSED_CROSSREF)

  @markup.add_regexp_handling(HTML_CHARACTERS_REGEXP, :HTML_CHARACTERS)

  @markup.add_regexp_handling(/\b['"`]/, :QUOTE_AFTER_WORD)
  @markup.add_regexp_handling(/\B['"`]/, :QUOTE_NOT_AFTER_WORD)

  init_link_notation_regexp_handlings
end

#list_end_for(list_type) ⇒ Object

Returns the HTML end-tag for list_type



685
686
687
688
689
690
691
692
693
694
 
# File 'lib/rdoc/markup/to_html.rb', line 685

def list_end_for(list_type)
  case list_type
  when :BULLET, :LALPHA, :NUMBER, :UALPHA
    "</li>"
  when :LABEL, :NOTE
    "</dd>"
  else
    raise Error, "Invalid list type: #{list_type.inspect}"
  end
end

#list_item_start(list_item, list_type) ⇒ Object

Returns the HTML tag for list_type, possible using a label from list_item



669
670
671
672
673
674
675
676
677
678
679
680
 
# File 'lib/rdoc/markup/to_html.rb', line 669

def list_item_start(list_item, list_type)
  case list_type
  when :BULLET, :LALPHA, :NUMBER, :UALPHA
    "<li>"
  when :LABEL, :NOTE
    Array(list_item.label).map do |label|
      "<dt>#{to_html label}</dt>\n"
    end.join << "<dd>"
  else
    raise Error, "Invalid list type: #{list_type.inspect}"
  end
end

#parsable_text_to_html(text) ⇒ Object

Generate syntax highlighted html for ruby-like text.



437
438
439
440
441
442
 
# File 'lib/rdoc/markup/to_html.rb', line 437

def parsable_text_to_html(text)
  tokens = ::RDoc::Parser::RubyColorizer.colorize(text)
  result = TokenStream.to_html tokens
  result = result + "\n" unless result.end_with?("\n")
  result
end

#parseable?(text) ⇒ Boolean

Returns true if text is valid ruby syntax

Returns:

  • (Boolean) 


699
700
701
 
# File 'lib/rdoc/markup/to_html.rb', line 699

def parseable?(text)
  Prism.parse_success?(text)
end

#start_accepting ⇒ Object

Prepares the visitor for HTML generation



395
396
397
398
399
400
 
# File 'lib/rdoc/markup/to_html.rb', line 395

def start_accepting
  @res = []
  @in_list_entry = []
  @list = []
  @heading_ids = {}
end

#to_html(item) ⇒ Object

Converts item to HTML using RDoc::Text#to_html



706
707
708
 
# File 'lib/rdoc/markup/to_html.rb', line 706

def to_html(item)
  handle_inline(item)
end

#unsafe_url?(url) ⇒ Boolean

Does url have a scheme in UNSAFE_URL_SCHEME_REGEXP?

Browsers ignore leading C0 controls and spaces and all ASCII tabs and newlines in a URL, so they are removed before checking the scheme. See https://url.spec.whatwg.org/#concept-basic-url-parser

: (String) -> bool

Returns:

  • (Boolean) 


651
652
653
654
 
# File 'lib/rdoc/markup/to_html.rb', line 651

def unsafe_url?(url)
  normalized = url.sub(/\A[\x00-\x20]+/, '').delete("\t\n\r")
  UNSAFE_URL_SCHEME_REGEXP.match?(normalized)
end