Class: RDoc::Markup::ToHtml (Ruby 2.7.2)
Description: Class : RDoc::Markup::ToHtml - Ruby 2.7.2

### Home Classes Methods

### In Files

- rdoc/markup/to_html.rb

### Parent

RDoc::Markup::Formatter

### Sections

- Regexp Handling
- Utilities
- Visitor

### Methods

- ::new
- #accept_blank_line
- #accept_block_quote
- #accept_heading
- #accept_list_end
- #accept_list_item_end
- #accept_list_item_start
- #accept_list_start
- #accept_paragraph
- #accept_raw
- #accept_rule
- #accept_verbatim
- #convert_string
- #end_accepting
- #gen_url
- #handle_regexp_HARD_BREAK
- #handle_regexp_HYPERLINK
- #handle_regexp_RDOCLINK
- #handle_regexp_TIDYLINK
- #html_list_name
- #init_tags
- #list_end_for
- #list_item_start
- #parseable?
- #start_accepting
- #to_html

### Included Modules

- RDoc::Text

### Class/Module Index

Quicksearch

- InnerStateLex
- Object
- RDoc
- RDoc::Alias
- RDoc::AnonClass
- RDoc::AnyMethod
- RDoc::Attr
- RDoc::ClassModule
- RDoc::CodeObject
- RDoc::Comment
- RDoc::Constant
- RDoc::Context
- RDoc::Context::Section
- RDoc::CrossReference
- RDoc::ERBIO
- RDoc::ERBPartial
- RDoc::Encoding
- RDoc::Error
- RDoc::Extend
- RDoc::Generator
- RDoc::Generator::Darkfish
- RDoc::Generator::JsonIndex
- RDoc::Generator::Markup
- RDoc::Generator::POT
- RDoc::Generator::POT::MessageExtractor
- RDoc::Generator::POT::PO
- RDoc::Generator::POT::POEntry
- RDoc::Generator::RI
- RDoc::GhostMethod
- RDoc::I18n
- RDoc::I18n::Locale
- RDoc::I18n::Text
- RDoc::Include
- RDoc::Markdown
- RDoc::Markdown::Literals
- RDoc::Markup
- RDoc::Markup::AttrChanger
- RDoc::Markup::AttrSpan
- RDoc::Markup::AttributeManager
- RDoc::Markup::Attributes
- RDoc::Markup::BlankLine
- RDoc::Markup::BlockQuote
- RDoc::Markup::Document
- RDoc::Markup::Formatter
- RDoc::Markup::HardBreak
- RDoc::Markup::Include
- RDoc::Markup::IndentedParagraph
- RDoc::Markup::List
- RDoc::Markup::ListItem
- RDoc::Markup::Paragraph
- RDoc::Markup::Parser
- RDoc::Markup::Parser::Error
- RDoc::Markup::Parser::MyStringScanner
- RDoc::Markup::Parser::ParseError
- RDoc::Markup::PreProcess
- RDoc::Markup::Raw
- RDoc::Markup::RegexpHandling
- RDoc::Markup::Rule
- RDoc::Markup::ToAnsi
- RDoc::Markup::ToBs
- RDoc::Markup::ToHtml
- RDoc::Markup::ToHtmlCrossref
- RDoc::Markup::ToHtmlSnippet
- RDoc::Markup::ToJoinedParagraph
- RDoc::Markup::ToLabel
- RDoc::Markup::ToMarkdown
- RDoc::Markup::ToRdoc
- RDoc::Markup::ToTableOfContents
- RDoc::Markup::ToTest
- RDoc::Markup::ToTtOnly
- RDoc::Markup::Verbatim
- RDoc::MetaMethod
- RDoc::MethodAttr
- RDoc::Mixin
- RDoc::NormalClass
- RDoc::NormalModule
- RDoc::Options
- RDoc::Parser
- RDoc::Parser::C
- RDoc::Parser::ChangeLog
- RDoc::Parser::Markdown
- RDoc::Parser::RD
- RDoc::Parser::RipperStateLex
- RDoc::Parser::RipperStateLex::InnerStateLex
- RDoc::Parser::Ruby
- RDoc::Parser::RubyTools
- RDoc::Parser::Simple
- RDoc::Parser::Text
- RDoc::RD
- RDoc::RD::BlockParser
- RDoc::RD::Inline
- RDoc::RD::InlineParser
- RDoc::RDoc
- RDoc::RI
- RDoc::RI::Driver
- RDoc::RI::Driver::Error
- RDoc::RI::Driver::NotFoundError
- RDoc::RI::Error
- RDoc::RI::Paths
- RDoc::RI::Task
- RDoc::Require
- RDoc::RubygemsHook
- RDoc::Servlet
- RDoc::SingleClass
- RDoc::Stats
- RDoc::Stats::Normal
- RDoc::Stats::Quiet
- RDoc::Stats::Verbose
- RDoc::Store
- RDoc::Store::Error
- RDoc::Store::MissingFileError
- RDoc::Task
- RDoc::Text
- RDoc::TokenStream
- RDoc::TomDoc
- RDoc::TopLevel
- RDocTask

No matching classes.

# RDoc::Markup::ToHtml

Outputs RDoc markup as HTML.

### Public Class Methods

new(options, markup = nil) click to toggle source

Creates a new formatter that will output HTML

                   # File rdoc/markup/to_html.rb, line 45
    def initialize options, markup = nil
      super

      @code_object = nil
      @from_path = ''
      @in_list_entry = nil
      @list = nil
      @th = nil
      @hard_break = "<br>\n"

      # external links
      @markup.add_regexp_handling(/(?:link:|https?:|mailto:|ftp:|irc:|www\.)\S+\w/,
                                  :HYPERLINK)

      add_regexp_handling_RDOCLINK
      add_regexp_handling_TIDYLINK

      init_tags
    end

## Regexp Handling ↑ top

### Public Instance Methods

handle_regexp_HARD_BREAK(target) click to toggle source

`target` is a `
`

                   # File rdoc/markup/to_html.rb, line 96
    def handle_regexp_HARD_BREAK target
      '<br>'
    end

handle_regexp_HYPERLINK(target) click to toggle source

`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 `<img>` tag. Otherwise a conventional `<a href>` is used.

`link:`

  Reference to a local file relative to the output directory.

                   # File rdoc/markup/to_html.rb, line 112
    def handle_regexp_HYPERLINK(target)
      url = target.text

      gen_url url, url
    end

handle_regexp_RDOCLINK(target) click to toggle source

`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.

                   # File rdoc/markup/to_html.rb, line 127
    def handle_regexp_RDOCLINK target
      handle_RDOCLINK target.text
    end

handle_regexp_TIDYLINK(target) click to toggle source

This `target` is a link where the label is different from the URL `label[url]` or `{long label}[url]`

                   # File rdoc/markup/to_html.rb, line 135
    def handle_regexp_TIDYLINK(target)
      text = target.text

      return text unless
        text =~ /^\{(.*)\}\[(.*?)\]$/ or text =~ /^(\S+)\[(.*?)\]$/

      label = $1
      url   = $2

      label = handle_RDOCLINK label if /^rdoc-image:/ =~ label

      gen_url url, label
    end

## Utilities ↑ top

### Constants

LIST_TYPE_TO_HTML

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

### Attributes

code_object[RW]

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

from_path[RW]

Path to this document for relative links

### Public Instance Methods

convert_string(text) click to toggle source

CGI-escapes `text`

                   # File rdoc/markup/to_html.rb, line 309
    def convert_string(text)
      CGI.escapeHTML text
    end

gen_url(url, text) click to toggle source

Generate a link to `url` with content `text`. Handles the special cases for img: and link: described under #handle_regexp_HYPERLINK

                   # File rdoc/markup/to_html.rb, line 317
    def gen_url url, text
      scheme, url, id = parse_url url

      if %w[http https link].include?(scheme) and
         url =~ /\.(gif|png|jpg|jpeg|bmp)$/ then
        "<img src=\"#{url}\" />"
      else
        text = text.sub %r%^#{scheme}:/*%i, ''
        text = text.sub %r%^[*\^](\d+)$%,   '\1'

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

        link = "<sup>#{link}</sup>" if /"foot/ =~ id

        link
      end
    end

html_list_name(list_type, open_tag) click to toggle source

Determines the HTML list element for `list_type` and `open_tag`

                   # File rdoc/markup/to_html.rb, line 338
    def html_list_name(list_type, open_tag)
      tags = LIST_TYPE_TO_HTML[list_type]
      raise RDoc::Error, "Invalid list type: #{list_type.inspect}" unless tags
      tags[open_tag ? 0 : 1]
    end

init_tags() click to toggle source

Maps attributes to HTML tags

                   # File rdoc/markup/to_html.rb, line 347
    def init_tags
      add_tag :BOLD, "<strong>", "</strong>"
      add_tag :TT,   "<code>",   "</code>"
      add_tag :EM,   "<em>",     "</em>"
    end

list_end_for(list_type) click to toggle source

Returns the HTML end-tag for `list_type`

                   # File rdoc/markup/to_html.rb, line 373
    def list_end_for(list_type)
      case list_type
      when :BULLET, :LALPHA, :NUMBER, :UALPHA then
        "</li>"
      when :LABEL, :NOTE then
        "</dd>"
      else
        raise RDoc::Error, "Invalid list type: #{list_type.inspect}"
      end
    end

list_item_start(list_item, list_type) click to toggle source

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

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

parseable?(text) click to toggle source

Returns true if text is valid ruby syntax

                   # File rdoc/markup/to_html.rb, line 387
    def parseable? text
      verbose, $VERBOSE = $VERBOSE, nil
      eval("BEGIN {return true}\n#{text}")
    rescue SyntaxError
      false
    ensure
      $VERBOSE = verbose
    end

to_html(item) click to toggle source

Converts `item` to HTML using RDoc::Text#to_html

                   # File rdoc/markup/to_html.rb, line 399
    def to_html item
      super convert_flow @am.flow item
    end

## Visitor ↑ top

### Public Instance Methods

accept_blank_line(blank_line) click to toggle source

Adds `blank_line` to the output

                   # File rdoc/markup/to_html.rb, line 271
    def accept_blank_line(blank_line)
      # @res << annotate("<p />") << "\n"
    end

accept_block_quote(block_quote) click to toggle source

Adds `block_quote` to the output

                   # File rdoc/markup/to_html.rb, line 172
    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) click to toggle source

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

                   # File rdoc/markup/to_html.rb, line 279
    def accept_heading heading
      level = [6, heading.level].min

      label = heading.label @code_object

      @res << if @options.output_decoration
                "\n<h#{level} id=\"#{label}\">"
              else
                "\n<h#{level}>"
              end
      @res << to_html(heading.text)
      unless @options.pipe then
        @res << "<span><a href=\"##{label}\">&para;</a>"
        @res << " <a href=\"#top\">&uarr;</a></span>"
      end
      @res << "</h#{level}>\n"
    end

accept_list_end(list) click to toggle source

Finishes consumption of `list`

                   # File rdoc/markup/to_html.rb, line 242
    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) click to toggle source

Finishes consumption of `list_item`

                   # File rdoc/markup/to_html.rb, line 264
    def accept_list_item_end(list_item)
      @in_list_entry[-1] = list_end_for(@list.last)
    end

accept_list_item_start(list_item) click to toggle source

Prepares the visitor for consuming `list_item`

                   # File rdoc/markup/to_html.rb, line 253
    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) click to toggle source

Prepares the visitor for consuming `list`

                   # File rdoc/markup/to_html.rb, line 233
    def accept_list_start(list)
      @list << list.type
      @res << html_list_name(list.type, true)
      @in_list_entry.push false
    end

accept_paragraph(paragraph) click to toggle source

Adds `paragraph` to the output

                   # File rdoc/markup/to_html.rb, line 185
    def accept_paragraph paragraph
      @res << "\n<p>"
      text = paragraph.text @hard_break
      text = text.gsub(/\r?\n/, ' ')
      @res << to_html(text)
      @res << "</p>\n"
    end

accept_raw(raw) click to toggle source

Adds `raw` to the output

                   # File rdoc/markup/to_html.rb, line 300
    def accept_raw raw
      @res << raw.parts.join("\n")
    end

accept_rule(rule) click to toggle source

Adds `rule` to the output

                   # File rdoc/markup/to_html.rb, line 226
    def accept_rule rule
      @res << "<hr>\n"
    end

accept_verbatim(verbatim) click to toggle source

Adds `verbatim` to the output

                   # File rdoc/markup/to_html.rb, line 196
    def accept_verbatim verbatim
      text = verbatim.text.rstrip

      klass = nil

      content = if verbatim.ruby? or parseable? text then
                  begin
                    tokens = RDoc::Parser::RipperStateLex.parse text
                    klass  = ' class="ruby"'

                    result = RDoc::TokenStream.to_html tokens
                    result = result + "\n" unless "\n" == result[-1]
                    result
                  rescue
                    CGI.escapeHTML text
                  end
                else
                  CGI.escapeHTML text
                end

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

end_accepting() click to toggle source

Returns the generated output

                   # File rdoc/markup/to_html.rb, line 165
    def end_accepting
      @res.join
    end

start_accepting() click to toggle source

Prepares the visitor for HTML generation

                   # File rdoc/markup/to_html.rb, line 156
    def start_accepting
      @res = []
      @in_list_entry = []
      @list = []
    end