class RDoc::Markdown

RDoc::Markdown as described by the markdown syntax.

To choose Markdown as your only default format see
Saved Options at RDoc::Options for instructions on setting up a .rdoc_options
file to store your project default.

Usage

Here is a brief example of using this parse to read a markdown file by hand.

data = File.read("README.md")
formatter = RDoc::Markup::ToHtml.new(RDoc::Options.new, nil)
html = RDoc::Markdown.parse(data).accept(formatter)

# do something with html

Extensions

The following markdown extensions are supported by the parser, but not all
are used in RDoc output by default.

RDoc

The RDoc Markdown parser has the following built-in behaviors that cannot be
disabled.

Underscores embedded in words are never interpreted as emphasis. (While the
markdown dingus emphasizes in-word underscores, neither the
Markdown syntax nor MarkdownTest mention this behavior.)

For HTML output, RDoc always auto-links bare URLs.

Break on Newline

The break_on_newline extension converts all newlines into hard line breaks
as in Github Flavored Markdown. This extension is disabled by
default.

CSS

The css extension enables CSS blocks to be included in the output, but they
are not used for any built-in RDoc output format. This extension is disabled
by default.

Example:

<style type="text/css">
h1 { font-size: 3em }
</style>

Definition Lists

The definition_lists extension allows definition lists using the PHP Markdown Extra syntax, but only one label and definition are supported
at this time. This extension is enabled by default.

Example:

cat
:   A small furry mammal
that seems to sleep a lot

ant
:   A little insect that is known
to enjoy picnics

Produces:

cat: A small furry mammal
that seems to sleep a lot
ant: A little insect that is known
to enjoy picnics

Github

The github extension enables a partial set of Github Flavored Markdown. This extension is enabled by default.

Supported github extensions include:

Fenced code blocks

Use ``` around a block of code instead of indenting it four spaces.

Syntax highlighting

Use ``` ruby as the start of a code fence to add syntax highlighting.
(Currently only ruby syntax is supported).

HTML

Enables raw HTML to be included in the output. This extension is enabled by
default.

Example:

<table>
...
</table>

Notes

The notes extension enables footnote support. This extension is enabled by
default.

Example:

Here is some text[^1] including an inline footnote ^[for short footnotes]

...

[^1]: With the footnote text down at the bottom

Produces:

Here is some text¹ including an inline footnote ²

Limitations

Link titles are not used
Footnotes are collapsed into a single paragraph

Author

This markdown parser is a port to kpeg from peg-markdown by
John MacFarlane.

It is used under the MIT license:

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.

The port to kpeg was performed by Eric Hodel and Evan Phoenix

¹ With the footnote text down at the bottom

² for short footnotes

Constants

DEFAULT_EXTENSIONS: Extensions enabled by default
EXTENSIONS: Supported extensions
HTML_ENTITIES: HTML entity name map for RDoc::Markdown

Public Class Methods

new (extensions = DEFAULT_EXTENSIONS, debug = false)

Source

# File lib/rdoc/markdown.rb, line 669
def initialize extensions = DEFAULT_EXTENSIONS, debug = false
  @debug      = debug
  @formatter  = RDoc::Markup::ToJoinedParagraph.new
  @extensions = extensions

  @references          = nil
  @unlinked_references = nil

  @footnotes       = nil
  @note_order      = nil
end

Creates a new markdown parser that enables the given +extensions+.

parse (markdown)

Source

# File lib/rdoc/markdown.rb, line 657
def self.parse markdown
  parser = new

  parser.parse markdown
end

Parses the markdown document into an RDoc::Document using the default
extensions.

Public Instance Methods

code (text)

Source

# File lib/rdoc/markdown.rb, line 899
def code text
  # trim even spaces
  text = $2 while /\A( +|\t+)(.*)\1\z/ =~ text
  # escape unescaped backslash at the end
  backslash_at_end = "\\" if /(?<!\\)(?:\\\\)*\\\z/.match?(text)
  "<code>#{text}#{backslash_at_end}</code>"
end

Wraps text in code markup for rdoc inline formatting

emphasis (text)

Source

# File lib/rdoc/markdown.rb, line 684
def emphasis text
  if text =~ /\A[a-z\d.\/]+\z/i then
    "_#{text}_"
  else
    "<em>#{text}</em>"
  end
end

Wraps text in emphasis for rdoc inline formatting

link_to (content, label = content, text = nil)

Source

# File lib/rdoc/markdown.rb, line 752
def link_to content, label = content, text = nil
  raise ParseError, 'enable notes extension' if
    content.start_with? '^' and label.equal? content

  if ref = @references[label] then
    "{#{content}}[#{ref}]"
  elsif label.equal? content then
    "[#{content}]#{text}"
  else
    "[#{content}]#{text}[#{label}]"
  end
end

Finds a link reference for label and creates a new link to it with
content as the link text. If label was not encountered in the
reference-gathering parser pass the label and content are reconstructed
with the linking text (usually whitespace).

list_item_from (unparsed)

Source

# File lib/rdoc/markdown.rb, line 769
def list_item_from unparsed
  parsed = inner_parse unparsed.join
  RDoc::Markup::ListItem.new nil, *parsed
end

Creates an RDoc::Markup::ListItem by parsing the unparsed content from
the first parsing pass.

note (label)

Source

# File lib/rdoc/markdown.rb, line 777
def note label
  #foottext = "rdoc-label:foottext-#{label}:footmark-#{label}"

  #ref.replace foottext if ref = @unlinked_notes.delete(label)

  @notes[label] = foottext

  #"{^1}[rdoc-label:footmark-#{label}:foottext-#{label}] "
end

Stores label as a note and fills in previously unknown note references.

note_for (ref)

Source

# File lib/rdoc/markdown.rb, line 791
def note_for ref
  @note_order << ref

  label = @note_order.length

  "{*#{label}}[rdoc-label:foottext-#{label}:footmark-#{label}]"
end

Creates a new link for the footnote reference and adds the reference to
the note order list for proper display at the end of the document.

paragraph (parts)

Source

# File lib/rdoc/markdown.rb, line 808
def paragraph parts
  parts = parts.map do |part|
    if "\n" == part then
      RDoc::Markup::HardBreak.new
    else
      part
    end
  end if break_on_newline?

  RDoc::Markup::Paragraph.new(*parts)
end

Creates an RDoc::Markup::Paragraph from parts and including
extension-specific behavior

parse (markdown)

Source

# File lib/rdoc/markdown.rb, line 823
def parse markdown
  @references          = {}
  @unlinked_references = {}

  markdown += "\n\n"

  setup_parser markdown, @debug
  peg_parse 'References'

  if notes? then
    @footnotes       = {}

    setup_parser markdown, @debug
    peg_parse 'Notes'

    # using note_order on the first pass would be a bug
    @note_order      = []
  end

  setup_parser markdown, @debug
  peg_parse

  doc = result

  if notes? and not @footnotes.empty? then
    doc << RDoc::Markup::Rule.new(1)

    @note_order.each_with_index do |ref, index|
      label = index + 1
      note = @footnotes[ref] or raise ParseError, "footnote [^#{ref}] not found"

      link = "{^#{label}}[rdoc-label:footmark-#{label}:foottext-#{label}] "
      note.parts.unshift link

      doc << note
    end
  end

  doc.accept @formatter

  doc
end

Parses markdown into an RDoc::Document

parse_cell_inline (text)

Source

# File lib/rdoc/markdown.rb, line 925
def parse_cell_inline(text)
  return text if text.nil? || text.empty?

  # Create a new parser instance for the cell
  cell_parser = RDoc::Markdown.new(@extensions, @debug)

  # Parse the cell content
  doc = cell_parser.parse(text)

  # Extract the parsed content
  if doc && doc.parts && !doc.parts.empty?
    para = doc.parts.first
    if para.is_a?(RDoc::Markup::Paragraph)
      para.parts.join
    else
      text
    end
  else
    text
  end
end

Parses inline markdown in a single table cell

parse_table_cells (table)

Source

# File lib/rdoc/markdown.rb, line 910
def parse_table_cells(table)
  # Parse header cells
  table.header = table.header.map { |cell| parse_cell_inline(cell) }

  # Parse body cells
  table.body = table.body.map do |row|
    row.map { |cell| parse_cell_inline(cell) }
  end

  table
end

Parses inline markdown in table cells

rdoc_escape (text)

Source

# File lib/rdoc/markdown.rb, line 695
def rdoc_escape(text)
  text.gsub(/[*+<\\_]/) {|s| "\\#{s}" }
end

Escape character that has special meaning in RDoc format.
To allow rdoc-styled link used in markdown format for now, bracket and brace are not escaped.

rdoc_link_url_escape (text)

Source

# File lib/rdoc/markdown.rb, line 702
def rdoc_link_url_escape(text)
  text.gsub(/[\[\]\\]/) {|s| "\\#{s}" }
end

Escape link url that contains brackets.
Brackets needs escape because link url will be surrounded by [] in RDoc format.

reference (label, link)

Source

# File lib/rdoc/markdown.rb, line 870
def reference label, link
  if ref = @unlinked_references.delete(label) then
    ref.replace link
  end

  @references[label] = link
end

Stores label as a reference to link and fills in previously unknown
link references.

strong (text)

Source

# File lib/rdoc/markdown.rb, line 881
def strong text
  if text =~ /\A[a-z\d.\/-]+\z/i then
    "*#{text}*"
  else
    "<b>#{text}</b>"
  end
end

Wraps text in strong markup for rdoc inline formatting

Extensions

Public Class Methods

extension (name)

Source

# File lib/rdoc/markdown.rb, line 604
def self.extension name
  EXTENSIONS << name

  define_method "#{name}?" do
    extension? name
  end

  define_method "#{name}=" do |enable|
    extension name, enable
  end
end

Creates extension methods for the name extension to enable and disable
the extension and to query if they are active.

Public Instance Methods

break_on_newline ()

Source

# File lib/rdoc/markdown.rb, line 619
extension :break_on_newline

Converts all newlines into hard breaks

css ()

Source

# File lib/rdoc/markdown.rb, line 624
extension :css

Allow style blocks

definition_lists ()

Source

# File lib/rdoc/markdown.rb, line 629
extension :definition_lists

Allow PHP Markdown Extras style definition lists

extension (name, enable)

Source

# File lib/rdoc/markdown.rb, line 720
def extension name, enable
  if enable then
    @extensions |= [name]
  else
    @extensions -= [name]
  end
end

Enables or disables the extension with name

extension? (name)

Source

# File lib/rdoc/markdown.rb, line 711
def extension? name
  @extensions.include? name
end

Is the extension name enabled?

github ()

Source

# File lib/rdoc/markdown.rb, line 634
extension :github

Allow Github Flavored Markdown

html ()

Source

# File lib/rdoc/markdown.rb, line 639
extension :html

Allow HTML

notes ()

Source

# File lib/rdoc/markdown.rb, line 644
extension :notes

Enables the notes extension

strike ()

Source

# File lib/rdoc/markdown.rb, line 649
extension :strike

Enables the strike extension