23s2s

✏️ Editing: markdown.kpeg

%% name = RDoc::Markdown

%% header {
# coding: UTF-8
# frozen_string_literal: true
# :markup: markdown

##
# RDoc::Markdown as described by the [markdown syntax][syntax].
#
# To choose Markdown as your only default format see
# RDoc::Options@Saved+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][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][GFM].  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][PHPE], 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
#
# ### Strike
#
# Example:
#
# ```
# This is ~~striked~~.
# ```
#
# Produces:
#
# This is ~~striked~~.
#
# ### Github
#
# The #github extension enables a partial set of [Github Flavored Markdown]
# [GFM].  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[^1] including an inline footnote ^[for short footnotes]
#
# [^1]: With the footnote text down at the bottom
#
# ## 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][pegmarkdown] 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
#
# [dingus]: http://daringfireball.net/projects/markdown/dingus
# [GFM]: https://github.github.com/gfm/
# [pegmarkdown]: https://github.com/jgm/peg-markdown
# [PHPE]: https://michelf.ca/projects/php-markdown/extra/#def-list
# [syntax]: http://daringfireball.net/projects/markdown/syntax
#--
# Last updated to jgm/peg-markdown commit 8f8fc22ef0

}

%% {

require_relative '../rdoc'
  require_relative 'markup/to_joined_paragraph'
  require_relative 'markdown/entities'

require_relative 'markdown/literals'

##
  # Supported extensions

EXTENSIONS = []

##
  # Extensions enabled by default

DEFAULT_EXTENSIONS = [
    :definition_lists,
    :github,
    :html,
    :notes,
    :strike,
  ]

# :section: Extensions

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

def self.extension name
    EXTENSIONS << name

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

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

##
  # Converts all newlines into hard breaks

extension :break_on_newline

##
  # Allow style blocks

extension :css

##
  # Allow PHP Markdown Extras style definition lists

extension :definition_lists

##
  # Allow Github Flavored Markdown

extension :github

##
  # Allow HTML

extension :html

##
  # Enables the notes extension

extension :notes

##
  # Enables the strike extension

extension :strike

# :section:

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

def self.parse markdown
    parser = new

parser.parse markdown
  end

# TODO remove when kpeg 0.10 is released
  alias orig_initialize initialize # :nodoc:

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

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

##
  # Wraps `text` in emphasis for rdoc inline formatting

def emphasis text
    if text =~ /\A[a-z\d.\/]+\z/i then
      "_#{text}_"
    else
      "<em>#{text}</em>"
    end
  end

##
  # :category: Extensions
  #
  # Is the extension `name` enabled?

def extension? name
    @extensions.include? name
  end

##
  # :category: Extensions
  #
  # Enables or disables the extension with `name`

def extension name, enable
    if enable then
      @extensions |= [name]
    else
      @extensions -= [name]
    end
  end

##
  # Parses `text` in a clone of this parser.  This is used for handling nested
  # lists the same way as markdown_parser.

def inner_parse text # :nodoc:
    parser = clone

parser.setup_parser text, @debug

parser.peg_parse

doc = parser.result

doc.accept @formatter

doc.parts
  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).

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

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

def list_item_from unparsed
    parsed = inner_parse unparsed.join
    RDoc::Markup::ListItem.new nil, *parsed
  end

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

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

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

def note_for ref
    @note_order << ref

label = @note_order.length

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

##
  # The internal kpeg parse method

alias peg_parse parse # :nodoc:

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

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

##
  # Parses `markdown` into an RDoc::Document

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

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

def reference label, link
    if ref = @unlinked_references.delete(label) then
      ref.replace link
    end

@references[label] = link
  end

##
  # Wraps `text` in strong markup for rdoc inline formatting

def strong text
    if text =~ /\A[a-z\d.\/-]+\z/i then
      "*#{text}*"
    else
      "<b>#{text}</b>"
    end
  end

##
  # Wraps `text` in strike markup for rdoc inline formatting

def strike text
    if text =~ /\A[a-z\d.\/-]+\z/i then
      "~#{text}~"
    else
      "<s>#{text}</s>"
    end
  end

##
  # Wraps `text` in code markup for rdoc inline formatting

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

##
  # Parses inline markdown in table cells

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 a single table cell

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
}

root = Doc

Doc =       BOM? Block*:a { RDoc::Markup::Document.new(*a.compact) }

Para =      @NonindentSpace Inlines:a @BlankLine+
            { paragraph a }

Plain =     Inlines:a
            { paragraph a }

AtxInline = !@Newline !(@Sp /#*/ @Sp @Newline) Inline

AtxStart =  < /\#{1,6}/ >
            { text.length }

AtxHeading = AtxStart:s @Spacechar+ AtxInline+:a (@Sp /#*/ @Sp)?  @Newline
            { RDoc::Markup::Heading.new(s, a.join) }

SetextHeading = SetextHeading1 | SetextHeading2

SetextBottom1 = /={1,}/ @Newline

SetextBottom2 = /-{1,}/ @Newline

SetextHeading1 =  &(@RawLine SetextBottom1)
                  @StartList:a ( !@Endline Inline:b { a << b } )+ @Sp @Newline
                  SetextBottom1
                  { RDoc::Markup::Heading.new(1, a.join) }

SetextHeading2 =  &(@RawLine SetextBottom2)
                  @StartList:a ( !@Endline Inline:b { a << b })+ @Sp @Newline
                  SetextBottom2
                  { RDoc::Markup::Heading.new(2, a.join) }

Heading = SetextHeading | AtxHeading

BlockQuote = BlockQuoteRaw:a
             { RDoc::Markup::BlockQuote.new(*a) }

BlockQuoteRaw =  @StartList:a
                 (( ">" " "? Line:l { a << l } )
                  ( !">" !@BlankLine Line:c { a << c } )*
                  ( @BlankLine:n { a << n } )*
                 )+
                 { inner_parse a.join }

NonblankIndentedLine = !@BlankLine IndentedLine

VerbatimChunk = @BlankLine*:a
                NonblankIndentedLine+:b
                { a.concat b }

Verbatim =     VerbatimChunk+:a
               { RDoc::Markup::Verbatim.new(*a.flatten) }

HorizontalRule = @NonindentSpace
                 ( "*" @Sp "*" @Sp "*" (@Sp "*")*
                 | "-" @Sp "-" @Sp "-" (@Sp "-")*
                 | "_" @Sp "_" @Sp "_" (@Sp "_")*)
                 @Sp @Newline @BlankLine+
                 { RDoc::Markup::Rule.new 1 }

Bullet = !HorizontalRule @NonindentSpace /[+*-]/ @Spacechar+

BulletList = &Bullet (ListTight | ListLoose):a
             { RDoc::Markup::List.new(:BULLET, *a) }

ListTight = ListItemTight+:a
            @BlankLine* !(Bullet | Enumerator)
            { a }

ListLoose = @StartList:a
            ( ListItem:b @BlankLine* { a << b } )+
            { a }

ListItem =  ( Bullet | Enumerator )
            @StartList:a
            ListBlock:b { a << b }
            ( ListContinuationBlock:c { a.push(*c) } )*
            { list_item_from a }

ListItemTight =
            ( Bullet | Enumerator )
            ListBlock:a
            ( !@BlankLine
              ListContinuationBlock:b { a.push(*b) } )*
            !ListContinuationBlock
            { list_item_from a }

ListBlock = !@BlankLine Line:a
            ListBlockLine*:c
            { [a, *c] }

ListContinuationBlock = @StartList:a
                        ( @BlankLine*
                          { a << "\n" } )
                        ( Indent
                          ListBlock:b { a.concat b } )+
                        { a }

Enumerator = @NonindentSpace [0-9]+ "." @Spacechar+

OrderedList = &Enumerator (ListTight | ListLoose):a
             { RDoc::Markup::List.new(:NUMBER, *a) }

ListBlockLine = !@BlankLine
                !( Indent? (Bullet | Enumerator) )
                !HorizontalRule
                OptionallyIndentedLine

# Parsers for different kinds of block-level HTML content.
# This is repetitive due to constraints of PEG grammar.

HtmlOpenAnchor = "<" Spnl ("a" | "A") Spnl HtmlAttribute* ">"
HtmlCloseAnchor = "<" Spnl "/" ("a" | "A") Spnl ">"
HtmlAnchor = HtmlOpenAnchor (HtmlAnchor | !HtmlCloseAnchor .)* HtmlCloseAnchor

HtmlBlockOpenAddress = "<" Spnl ("address" | "ADDRESS") Spnl HtmlAttribute* ">"
HtmlBlockCloseAddress = "<" Spnl "/" ("address" | "ADDRESS") Spnl ">"
HtmlBlockAddress = HtmlBlockOpenAddress (HtmlBlockAddress | !HtmlBlockCloseAddress .)* HtmlBlockCloseAddress

HtmlBlockOpenBlockquote = "<" Spnl ("blockquote" | "BLOCKQUOTE") Spnl HtmlAttribute* ">"
HtmlBlockCloseBlockquote = "<" Spnl "/" ("blockquote" | "BLOCKQUOTE") Spnl ">"
HtmlBlockBlockquote = HtmlBlockOpenBlockquote (HtmlBlockBlockquote | !HtmlBlockCloseBlockquote .)* HtmlBlockCloseBlockquote

HtmlBlockOpenCenter = "<" Spnl ("center" | "CENTER") Spnl HtmlAttribute* ">"
HtmlBlockCloseCenter = "<" Spnl "/" ("center" | "CENTER") Spnl ">"
HtmlBlockCenter = HtmlBlockOpenCenter (HtmlBlockCenter | !HtmlBlockCloseCenter .)* HtmlBlockCloseCenter

HtmlBlockOpenDir = "<" Spnl ("dir" | "DIR") Spnl HtmlAttribute* ">"
HtmlBlockCloseDir = "<" Spnl "/" ("dir" | "DIR") Spnl ">"
HtmlBlockDir = HtmlBlockOpenDir (HtmlBlockDir | !HtmlBlockCloseDir .)* HtmlBlockCloseDir

HtmlBlockOpenDiv = "<" Spnl ("div" | "DIV") Spnl HtmlAttribute* ">"
HtmlBlockCloseDiv = "<" Spnl "/" ("div" | "DIV") Spnl ">"
HtmlBlockDiv = HtmlBlockOpenDiv (HtmlBlockDiv | !HtmlBlockCloseDiv .)* HtmlBlockCloseDiv

HtmlBlockOpenDl = "<" Spnl ("dl" | "DL") Spnl HtmlAttribute* ">"
HtmlBlockCloseDl = "<" Spnl "/" ("dl" | "DL") Spnl ">"
HtmlBlockDl = HtmlBlockOpenDl (HtmlBlockDl | !HtmlBlockCloseDl .)* HtmlBlockCloseDl

HtmlBlockOpenFieldset = "<" Spnl ("fieldset" | "FIELDSET") Spnl HtmlAttribute* ">"
HtmlBlockCloseFieldset = "<" Spnl "/" ("fieldset" | "FIELDSET") Spnl ">"
HtmlBlockFieldset = HtmlBlockOpenFieldset (HtmlBlockFieldset | !HtmlBlockCloseFieldset .)* HtmlBlockCloseFieldset

HtmlBlockOpenForm = "<" Spnl ("form" | "FORM") Spnl HtmlAttribute* ">"
HtmlBlockCloseForm = "<" Spnl "/" ("form" | "FORM") Spnl ">"
HtmlBlockForm = HtmlBlockOpenForm (HtmlBlockForm | !HtmlBlockCloseForm .)* HtmlBlockCloseForm

HtmlBlockOpenH1 = "<" Spnl ("h1" | "H1") Spnl HtmlAttribute* ">"
HtmlBlockCloseH1 = "<" Spnl "/" ("h1" | "H1") Spnl ">"
HtmlBlockH1 = HtmlBlockOpenH1 (HtmlBlockH1 | !HtmlBlockCloseH1 .)* HtmlBlockCloseH1

HtmlBlockOpenH2 = "<" Spnl ("h2" | "H2") Spnl HtmlAttribute* ">"
HtmlBlockCloseH2 = "<" Spnl "/" ("h2" | "H2") Spnl ">"
HtmlBlockH2 = HtmlBlockOpenH2 (HtmlBlockH2 | !HtmlBlockCloseH2 .)* HtmlBlockCloseH2

HtmlBlockOpenH3 = "<" Spnl ("h3" | "H3") Spnl HtmlAttribute* ">"
HtmlBlockCloseH3 = "<" Spnl "/" ("h3" | "H3") Spnl ">"
HtmlBlockH3 = HtmlBlockOpenH3 (HtmlBlockH3 | !HtmlBlockCloseH3 .)* HtmlBlockCloseH3

HtmlBlockOpenH4 = "<" Spnl ("h4" | "H4") Spnl HtmlAttribute* ">"
HtmlBlockCloseH4 = "<" Spnl "/" ("h4" | "H4") Spnl ">"
HtmlBlockH4 = HtmlBlockOpenH4 (HtmlBlockH4 | !HtmlBlockCloseH4 .)* HtmlBlockCloseH4

HtmlBlockOpenH5 = "<" Spnl ("h5" | "H5") Spnl HtmlAttribute* ">"
HtmlBlockCloseH5 = "<" Spnl "/" ("h5" | "H5") Spnl ">"
HtmlBlockH5 = HtmlBlockOpenH5 (HtmlBlockH5 | !HtmlBlockCloseH5 .)* HtmlBlockCloseH5

HtmlBlockOpenH6 = "<" Spnl ("h6" | "H6") Spnl HtmlAttribute* ">"
HtmlBlockCloseH6 = "<" Spnl "/" ("h6" | "H6") Spnl ">"
HtmlBlockH6 = HtmlBlockOpenH6 (HtmlBlockH6 | !HtmlBlockCloseH6 .)* HtmlBlockCloseH6

HtmlBlockOpenMenu = "<" Spnl ("menu" | "MENU") Spnl HtmlAttribute* ">"
HtmlBlockCloseMenu = "<" Spnl "/" ("menu" | "MENU") Spnl ">"
HtmlBlockMenu = HtmlBlockOpenMenu (HtmlBlockMenu | !HtmlBlockCloseMenu .)* HtmlBlockCloseMenu

HtmlBlockOpenNoframes = "<" Spnl ("noframes" | "NOFRAMES") Spnl HtmlAttribute* ">"
HtmlBlockCloseNoframes = "<" Spnl "/" ("noframes" | "NOFRAMES") Spnl ">"
HtmlBlockNoframes = HtmlBlockOpenNoframes (HtmlBlockNoframes | !HtmlBlockCloseNoframes .)* HtmlBlockCloseNoframes

HtmlBlockOpenNoscript = "<" Spnl ("noscript" | "NOSCRIPT") Spnl HtmlAttribute* ">"
HtmlBlockCloseNoscript = "<" Spnl "/" ("noscript" | "NOSCRIPT") Spnl ">"
HtmlBlockNoscript = HtmlBlockOpenNoscript (HtmlBlockNoscript | !HtmlBlockCloseNoscript .)* HtmlBlockCloseNoscript

HtmlBlockOpenOl = "<" Spnl ("ol" | "OL") Spnl HtmlAttribute* ">"
HtmlBlockCloseOl = "<" Spnl "/" ("ol" | "OL") Spnl ">"
HtmlBlockOl = HtmlBlockOpenOl (HtmlBlockOl | !HtmlBlockCloseOl .)* HtmlBlockCloseOl

HtmlBlockOpenP = "<" Spnl ("p" | "P") Spnl HtmlAttribute* ">"
HtmlBlockCloseP = "<" Spnl "/" ("p" | "P") Spnl ">"
HtmlBlockP = HtmlBlockOpenP (HtmlBlockP | !HtmlBlockCloseP .)* HtmlBlockCloseP

HtmlBlockOpenPre = "<" Spnl ("pre" | "PRE") Spnl HtmlAttribute* ">"
HtmlBlockClosePre = "<" Spnl "/" ("pre" | "PRE") Spnl ">"
HtmlBlockPre = HtmlBlockOpenPre (HtmlBlockPre | !HtmlBlockClosePre .)* HtmlBlockClosePre

HtmlBlockOpenTable = "<" Spnl ("table" | "TABLE") Spnl HtmlAttribute* ">"
HtmlBlockCloseTable = "<" Spnl "/" ("table" | "TABLE") Spnl ">"
HtmlBlockTable = HtmlBlockOpenTable (HtmlBlockTable | !HtmlBlockCloseTable .)* HtmlBlockCloseTable

HtmlBlockOpenUl = "<" Spnl ("ul" | "UL") Spnl HtmlAttribute* ">"
HtmlBlockCloseUl = "<" Spnl "/" ("ul" | "UL") Spnl ">"
HtmlBlockUl = HtmlBlockOpenUl (HtmlBlockUl | !HtmlBlockCloseUl .)* HtmlBlockCloseUl

HtmlBlockOpenDd = "<" Spnl ("dd" | "DD") Spnl HtmlAttribute* ">"
HtmlBlockCloseDd = "<" Spnl "/" ("dd" | "DD") Spnl ">"
HtmlBlockDd = HtmlBlockOpenDd (HtmlBlockDd | !HtmlBlockCloseDd .)* HtmlBlockCloseDd

HtmlBlockOpenDt = "<" Spnl ("dt" | "DT") Spnl HtmlAttribute* ">"
HtmlBlockCloseDt = "<" Spnl "/" ("dt" | "DT") Spnl ">"
HtmlBlockDt = HtmlBlockOpenDt (HtmlBlockDt | !HtmlBlockCloseDt .)* HtmlBlockCloseDt

HtmlBlockOpenFrameset = "<" Spnl ("frameset" | "FRAMESET") Spnl HtmlAttribute* ">"
HtmlBlockCloseFrameset = "<" Spnl "/" ("frameset" | "FRAMESET") Spnl ">"
HtmlBlockFrameset = HtmlBlockOpenFrameset (HtmlBlockFrameset | !HtmlBlockCloseFrameset .)* HtmlBlockCloseFrameset

HtmlBlockOpenLi = "<" Spnl ("li" | "LI") Spnl HtmlAttribute* ">"
HtmlBlockCloseLi = "<" Spnl "/" ("li" | "LI") Spnl ">"
HtmlBlockLi = HtmlBlockOpenLi (HtmlBlockLi | !HtmlBlockCloseLi .)* HtmlBlockCloseLi

HtmlBlockOpenTbody = "<" Spnl ("tbody" | "TBODY") Spnl HtmlAttribute* ">"
HtmlBlockCloseTbody = "<" Spnl "/" ("tbody" | "TBODY") Spnl ">"
HtmlBlockTbody = HtmlBlockOpenTbody (HtmlBlockTbody | !HtmlBlockCloseTbody .)* HtmlBlockCloseTbody

HtmlBlockOpenTd = "<" Spnl ("td" | "TD") Spnl HtmlAttribute* ">"
HtmlBlockCloseTd = "<" Spnl "/" ("td" | "TD") Spnl ">"
HtmlBlockTd = HtmlBlockOpenTd (HtmlBlockTd | !HtmlBlockCloseTd .)* HtmlBlockCloseTd

HtmlBlockOpenTfoot = "<" Spnl ("tfoot" | "TFOOT") Spnl HtmlAttribute* ">"
HtmlBlockCloseTfoot = "<" Spnl "/" ("tfoot" | "TFOOT") Spnl ">"
HtmlBlockTfoot = HtmlBlockOpenTfoot (HtmlBlockTfoot | !HtmlBlockCloseTfoot .)* HtmlBlockCloseTfoot

HtmlBlockOpenTh = "<" Spnl ("th" | "TH") Spnl HtmlAttribute* ">"
HtmlBlockCloseTh = "<" Spnl "/" ("th" | "TH") Spnl ">"
HtmlBlockTh = HtmlBlockOpenTh (HtmlBlockTh | !HtmlBlockCloseTh .)* HtmlBlockCloseTh

HtmlBlockOpenThead = "<" Spnl ("thead" | "THEAD") Spnl HtmlAttribute* ">"
HtmlBlockCloseThead = "<" Spnl "/" ("thead" | "THEAD") Spnl ">"
HtmlBlockThead = HtmlBlockOpenThead (HtmlBlockThead | !HtmlBlockCloseThead .)* HtmlBlockCloseThead

HtmlBlockOpenTr = "<" Spnl ("tr" | "TR") Spnl HtmlAttribute* ">"
HtmlBlockCloseTr = "<" Spnl "/" ("tr" | "TR") Spnl ">"
HtmlBlockTr = HtmlBlockOpenTr (HtmlBlockTr | !HtmlBlockCloseTr .)* HtmlBlockCloseTr

HtmlBlockOpenScript = "<" Spnl ("script" | "SCRIPT") Spnl HtmlAttribute* ">"
HtmlBlockCloseScript = "<" Spnl "/" ("script" | "SCRIPT") Spnl ">"
HtmlBlockScript = HtmlBlockOpenScript (!HtmlBlockCloseScript .)* HtmlBlockCloseScript

HtmlBlockOpenHead = "<" Spnl ("head" | "HEAD") Spnl HtmlAttribute* ">"
HtmlBlockCloseHead = "<" Spnl "/" ("head" | "HEAD") Spnl ">"
HtmlBlockHead = HtmlBlockOpenHead (!HtmlBlockCloseHead .)* HtmlBlockCloseHead

HtmlBlock = < ( HtmlBlockInTags | HtmlComment | HtmlBlockSelfClosing | HtmlUnclosed) >
            @BlankLine+
            { if html? then
                RDoc::Markup::Raw.new text
              end }

HtmlUnclosed = "<" Spnl HtmlUnclosedType Spnl HtmlAttribute* Spnl ">"

HtmlUnclosedType = "HR" | "hr"

HtmlBlockSelfClosing = "<" Spnl HtmlBlockType Spnl HtmlAttribute* "/" Spnl ">"

HtmlBlockType = "ADDRESS" |
                "BLOCKQUOTE" |
                "CENTER" |
                "DD" |
                "DIR" |
                "DIV" |
                "DL" |
                "DT" |
                "FIELDSET" |
                "FORM" |
                "FRAMESET" |
                "H1" |
                "H2" |
                "H3" |
                "H4" |
                "H5" |
                "H6" |
                "HR" |
                "ISINDEX" |
                "LI" |
                "MENU" |
                "NOFRAMES" |
                "NOSCRIPT" |
                "OL" |
                "P" |
                "PRE" |
                "SCRIPT" |
                "TABLE" |
                "TBODY" |
                "TD" |
                "TFOOT" |
                "TH" |
                "THEAD" |
                "TR" |
                "UL" |
                "address" |
                "blockquote" |
                "center" |
                "dd" |
                "dir" |
                "div" |
                "dl" |
                "dt" |
                "fieldset" |
                "form" |
                "frameset" |
                "h1" |
                "h2" |
                "h3" |
                "h4" |
                "h5" |
                "h6" |
                "hr" |
                "isindex" |
                "li" |
                "menu" |
                "noframes" |
                "noscript" |
                "ol" |
                "p" |
                "pre" |
                "script" |
                "table" |
                "tbody" |
                "td" |
                "tfoot" |
                "th" |
                "thead" |
                "tr" |
                "ul"

StyleOpen =     "<" Spnl ("style" | "STYLE") Spnl HtmlAttribute* ">"
StyleClose =    "<" Spnl "/" ("style" | "STYLE") Spnl ">"
InStyleTags =   StyleOpen (!StyleClose .)* StyleClose
StyleBlock =    < InStyleTags >
                @BlankLine*
                { if css? then
                    RDoc::Markup::Raw.new text
                  end }

Inlines  =  ( !@Endline Inline:i { i }
            | @Endline:c !( &{ github? } Ticks3 /[^`\n]*$/ )
	      &Inline { c } )+:chunks @Endline?
            { chunks }

Space = @Spacechar+ { " " }

Str = @StartList:a
      < @NormalChar+ > { a = text }
      ( StrChunk:c { a << c } )* { a }

StrChunk = < (@NormalChar | /_+/ &Alphanumeric)+ > { text }

EscapedChar =   "\\" !@Newline < /[:\\`|*_{}\[\]()#+.!><-]/ > { text }

Entity =    ( HexEntity | DecEntity | CharEntity ):a { a }

Endline =   @LineBreak | @TerminalEndline | @NormalEndline

NormalEndline =   @Sp @Newline !@BlankLine !">" !AtxStart
                  !(Line /={1,}|-{1,}/ @Newline)
                  { "\n" }

TerminalEndline = @Sp @Newline @Eof

LineBreak = "  " @NormalEndline { RDoc::Markup::HardBreak.new }

Symbol = < @SpecialChar >
         { text }

# This keeps the parser from getting bogged down on long strings of '*' or '_',
# or strings of '*' or '_' with space on each side:
UlOrStarLine =  (UlLine | StarLine):a { a }
StarLine = < /\*{4,}/ > { text } |
           < @Spacechar /\*+/ &@Spacechar > { text }
UlLine   = < /_{4,}/ > { text } |
           < @Spacechar /_+/ &@Spacechar > { text }

Emph =      EmphStar | EmphUl

Whitespace = @Spacechar | @Newline

EmphStar =  "*" !@Whitespace
            @StartList:a
            ( !"*" Inline:b { a << b }
            | StrongStar:b  { a << b }
            )+
            "*"
            { emphasis a.join }

EmphUl =    "_" !@Whitespace
            @StartList:a
            ( !"_" Inline:b { a << b }
            | StrongUl:b  { a << b }
            )+
            "_"
            { emphasis a.join }

Strong = StrongStar | StrongUl

StrongStar =    "**" !@Whitespace
                @StartList:a
                ( !"**" Inline:b { a << b } )+
                "**"
                { strong a.join }

StrongUl   =    "__" !@Whitespace
                @StartList:a
                ( !"__" Inline:b { a << b } )+
                "__"
                { strong a.join }

Strike = &{ strike? }
         "~~" !@Whitespace
         @StartList:a
         ( !"~~" Inline:b { a << b } )+
         "~~"
         { strike a.join }

Image = "!" ExplicitLinkWithLabel:a
        { "rdoc-image:#{a[:link]}:#{a[:label]}" }

Link =  ExplicitLink | ReferenceLink | AutoLink

ReferenceLink = ReferenceLinkDouble | ReferenceLinkSingle

ReferenceLinkDouble = Label:content < Spnl > !"[]" Label:label
                      { link_to content, label, text }

ReferenceLinkSingle = Label:content < (Spnl "[]")? >
                      { link_to content, content, text }

ExplicitLink = ExplicitLinkWithLabel:a
               { "{#{a[:label]}}[#{a[:link]}]" }

ExplicitLinkWithLabel = Label:label "(" @Sp Source:link Spnl Title @Sp ")"
                        { { label: label, link: link } }

Source  = ( "<" < SourceContents > ">" | < SourceContents > )
          { text }

SourceContents = ( ( !"(" !")" !">" Nonspacechar )+ | "(" SourceContents ")")*

Title = ( TitleSingle | TitleDouble | "" ):a
        { a }

TitleSingle = "'" ( !( "'" @Sp ( ")" | @Newline ) ) . )* "'"

TitleDouble = "\"" ( !( "\"" @Sp ( ")" | @Newline ) ) . )* "\""

AutoLink = AutoLinkUrl | AutoLinkEmail

AutoLinkUrl =   "<" < /[A-Za-z]+/ "://" ( !@Newline !">" . )+ > ">"
                { text }

AutoLinkEmail = "<" ("mailto:")? < /[\w+.\/!%~$-]+/i "@" ( !@Newline !">" . )+ > ">"
                { "mailto:#{text}" }

Reference = @NonindentSpace !"[]"
              Label:label ":" Spnl RefSrc:link RefTitle @BlankLine+
            { # TODO use title
              reference label, link
              nil
            }

Label = "[" ( !"^" &{ notes? } | &. &{ !notes? } )
        @StartList:a
        ( !"]" Inline:l { a << l } )*
        "]"
        { a.join.gsub(/\s+/, ' ') }

RefSrc = < Nonspacechar+ > { text }

RefTitle = ( RefTitleSingle | RefTitleDouble | RefTitleParens | EmptyTitle )

EmptyTitle = ""

RefTitleSingle = Spnl "'" < ( !( "'" @Sp @Newline | @Newline ) . )* > "'" { text }

RefTitleDouble = Spnl "\"" < ( !("\"" @Sp @Newline | @Newline) . )* > "\"" { text }

RefTitleParens = Spnl "(" < ( !(")" @Sp @Newline | @Newline) . )* > ")" { text }

References = ( Reference | SkipBlock )*

Ticks1 = "`" !"`"
Ticks2 = "``" !"`"
Ticks3 = "```" !"`"
Ticks4 = "````" !"`"
Ticks5 = "`````" !"`"

Code = ( Ticks1 < (
           ( !"`" Nonspacechar )+ | !Ticks1 /`+/ |
           !Ticks1 ( @Spacechar | @Newline !@BlankLine )
         )+ > Ticks1 |
         Ticks2 < (
           ( !"`" Nonspacechar )+ |
           !Ticks2 /`+/ |
           !Ticks2 ( @Spacechar | @Newline !@BlankLine )
         )+ > Ticks2 |
         Ticks3 < (
           ( !"`" Nonspacechar )+ |
           !Ticks3 /`+/ |
           !Ticks3 ( @Spacechar | @Newline !@BlankLine )
         )+ > Ticks3 |
         Ticks4 < (
           ( !"`" Nonspacechar )+ |
           !Ticks4 /`+/ |
           !Ticks4 ( @Spacechar | @Newline !@BlankLine )
         )+ > Ticks4 |
         Ticks5 < (
           ( !"`" Nonspacechar )+ |
           !Ticks5 /`+/ |
           !Ticks5 ( @Spacechar | @Newline !@BlankLine )
         )+ > Ticks5
       )
       { code text }

RawHtml = < (HtmlComment | HtmlBlockScript | HtmlTag) >
          { if html? then text else '' end }

BlankLine =     @Sp @Newline { "\n" }

Quoted =        "\"" (!"\"" .)* "\"" | "'" (!"'" .)* "'"
HtmlAttribute = (AlphanumericAscii | "-")+ Spnl ("=" Spnl (Quoted | (!">" Nonspacechar)+))? Spnl
HtmlComment =   "" .)* "-->"
HtmlTag =       "<" Spnl "/"? AlphanumericAscii+ Spnl HtmlAttribute* "/"? Spnl ">"
Eof =           !.
Nonspacechar =  !@Spacechar !@Newline .
Sp =            @Spacechar*
Spnl =          @Sp (@Newline @Sp)?
SpecialChar =   /[~*_`&\[\]()<!#\\'"]/ | @ExtendedSpecialChar
NormalChar =    !( @SpecialChar | @Spacechar | @Newline ) .
Digit = [0-9]

%literals         = RDoc::Markdown::Literals
Alphanumeric      = %literals.Alphanumeric
AlphanumericAscii = %literals.AlphanumericAscii
BOM               = %literals.BOM
Newline           = %literals.Newline
Spacechar         = %literals.Spacechar

HexEntity  = /&#x/i < /[0-9a-fA-F]+/ > ";"
             { [text.to_i(16)].pack 'U' }
DecEntity  = "&#"   < /[0-9]+/       > ";"
             { [text.to_i].pack 'U' }
CharEntity = "&"    </[A-Za-z0-9]+/  > ";"
             { if entity = HTML_ENTITIES[text] then
                 entity.pack 'U*'
               else
                 "&#{text};"
               end
             }

NonindentSpace =    / {0,3}/
Indent =            /\t|    /
IndentedLine =      Indent Line
OptionallyIndentedLine = Indent? Line

# StartList starts a list data structure that can be added to with cons:
StartList = &.
            { [] }

Line =  @RawLine:a { a }
RawLine = ( < /[^\r\n]*/ @Newline >
        | < .+ > @Eof ) { text }

SkipBlock = HtmlBlock
          | ( !"#" !SetextBottom1 !SetextBottom2 !@BlankLine @RawLine )+
            @BlankLine*
          | @BlankLine+
          | @RawLine

# Syntax extensions

ExtendedSpecialChar = &{ notes? } ( "^" )

NoteReference = &{ notes? }
                RawNoteReference:ref
                { note_for ref }

RawNoteReference = "[^" < ( !@Newline !"]" . )+ > "]" { text }

# TODO multiple paragraphs for a footnote
Note =          &{ notes? }
                @NonindentSpace RawNoteReference:ref ":" @Sp
                @StartList:a
                RawNoteBlock:i { a.concat i }
                ( &Indent RawNoteBlock:i { a.concat i } )*
                { @footnotes[ref] = paragraph a

nil
                }

InlineNote = &{ notes? }
             "^["
             @StartList:a
             ( !"]" Inline:l { a << l } )+
             "]"
             { ref = [:inline, @note_order.length]
               @footnotes[ref] = paragraph a

note_for ref
             }

Notes = ( Note | SkipBlock )*

RawNoteBlock = @StartList:a
               ( !@BlankLine !RawNoteReference OptionallyIndentedLine:l { a << l } )+
               ( < @BlankLine* > { a << text } )
               { a }

# Markdown extensions added by RDoc follow

CodeFence = &{ github? }
            Ticks3 (@Sp StrChunk:format)? Spnl < (
              ( !"`" Nonspacechar )+ |
              !Ticks3 /`+/ |
              Spacechar |
              @Newline
            )+ > Ticks3 @Sp @Newline*
            { verbatim = RDoc::Markup::Verbatim.new text
              verbatim.format = format.intern if format.instance_of?(String)
              verbatim
            }

Table = &{ github? }
        TableHead:header TableLine:line TableRow+:body
        {
          table = RDoc::Markup::Table.new(header, line, body)
          parse_table_cells(table)
        }

TableHead = TableItem2+:items "|"? @Newline
            { items }

TableRow = ( ( TableItem:item1 TableItem2*:items { [item1, *items] } ):row | TableItem2+:row ) "|"? @Newline
	   { row }
TableItem2 = "|" TableItem
TableItem = < /(?:\\.|[^|\n])+/ >
	    { text.strip.gsub(/\\([|])/, '\1')  }

TableLine = ( ( TableAlign:align1 TableAlign2*:aligns {[align1, *aligns] } ):line | TableAlign2+:line ) "|"? @Newline
	    { line }
TableAlign2 = "|" @Sp TableAlign
TableAlign = < /:?-+:?/ > @Sp
              {
                text.start_with?(":") ?
                (text.end_with?(":") ? :center : :left) :
                (text.end_with?(":") ? :right : nil)
              }

DefinitionList = &{ definition_lists? }
                 ( DefinitionListItem+:list )
                 { RDoc::Markup::List.new :NOTE, *list.flatten }

DefinitionListItem = ( DefinitionListLabel+ ):label
                     ( DefinitionListDefinition+ ):defns
                     { list_items = []
                       list_items <<
                         RDoc::Markup::ListItem.new(label, defns.shift)

list_items.concat defns.map { |defn|
                         RDoc::Markup::ListItem.new nil, defn
                       } unless list_items.empty?

list_items
                     }

DefinitionListLabel = Inline:label @Sp @Newline
                      { label }

DefinitionListDefinition = @NonindentSpace ":" @Space Inlines:a @BlankLine+
                           { paragraph a }

Sid Gifari From Gifari Industries - BD Cyber Security Team