357 lines
10 KiB
Julia
357 lines
10 KiB
Julia
# This file is a part of Julia. License is MIT: https://julialang.org/license
|
|
|
|
# ––––––––––
|
|
# Paragraphs
|
|
# ––––––––––
|
|
|
|
mutable struct Paragraph
|
|
content
|
|
end
|
|
|
|
Paragraph() = Paragraph([])
|
|
|
|
function paragraph(stream::IO, md::MD)
|
|
buffer = IOBuffer()
|
|
p = Paragraph()
|
|
push!(md, p)
|
|
skipwhitespace(stream)
|
|
prev_char = '\n'
|
|
while !eof(stream)
|
|
char = read(stream, Char)
|
|
if char == '\n' || char == '\r'
|
|
char == '\r' && !eof(stream) && Char(peek(stream)) == '\n' && read(stream, Char)
|
|
if prev_char == '\\'
|
|
write(buffer, '\n')
|
|
elseif blankline(stream) || parse(stream, md, breaking = true)
|
|
break
|
|
else
|
|
write(buffer, ' ')
|
|
end
|
|
else
|
|
write(buffer, char)
|
|
end
|
|
prev_char = char
|
|
end
|
|
p.content = parseinline(seek(buffer, 0), md)
|
|
return true
|
|
end
|
|
|
|
# –––––––
|
|
# Headers
|
|
# –––––––
|
|
|
|
mutable struct Header{level}
|
|
text
|
|
end
|
|
|
|
Header(s, level::Int) = Header{level}(s)
|
|
Header(s) = Header(s, 1)
|
|
|
|
@breaking true ->
|
|
function hashheader(stream::IO, md::MD)
|
|
withstream(stream) do
|
|
eatindent(stream) || return false
|
|
level = 0
|
|
while startswith(stream, '#') level += 1 end
|
|
level < 1 || level > 6 && return false
|
|
|
|
c = ' '
|
|
# Allow empty headers, but require a space
|
|
!eof(stream) && (c = read(stream, Char); !(c in " \n")) &&
|
|
return false
|
|
|
|
if c != '\n' # Empty header
|
|
h = strip(readline(stream))
|
|
h = match(r"(.*?)( +#+)?$", h).captures[1]
|
|
buffer = IOBuffer()
|
|
print(buffer, h)
|
|
push!(md.content, Header(parseinline(seek(buffer, 0), md), level))
|
|
else
|
|
push!(md.content, Header("", level))
|
|
end
|
|
return true
|
|
end
|
|
end
|
|
|
|
function setextheader(stream::IO, md::MD)
|
|
withstream(stream) do
|
|
eatindent(stream) || return false
|
|
header = strip(readline(stream))
|
|
isempty(header) && return false
|
|
|
|
eatindent(stream) || return false
|
|
underline = strip(readline(stream))
|
|
length(underline) < 3 && return false
|
|
u = underline[1]
|
|
u in "-=" || return false
|
|
all(c -> c == u, underline) || return false
|
|
level = (u == '=') ? 1 : 2
|
|
|
|
push!(md.content, Header(parseinline(header, md), level))
|
|
return true
|
|
end
|
|
end
|
|
|
|
# ––––
|
|
# Code
|
|
# ––––
|
|
|
|
mutable struct Code
|
|
language::String
|
|
code::String
|
|
end
|
|
|
|
Code(code) = Code("", code)
|
|
|
|
function indentcode(stream::IO, block::MD)
|
|
withstream(stream) do
|
|
buffer = IOBuffer()
|
|
while !eof(stream)
|
|
if startswith(stream, " ") || startswith(stream, "\t")
|
|
write(buffer, readline(stream, chomp=false))
|
|
elseif blankline(stream)
|
|
write(buffer, '\n')
|
|
else
|
|
break
|
|
end
|
|
end
|
|
code = String(take!(buffer))
|
|
!isempty(code) && (push!(block, Code(rstrip(code))); return true)
|
|
return false
|
|
end
|
|
end
|
|
|
|
# --------
|
|
# Footnote
|
|
# --------
|
|
|
|
mutable struct Footnote
|
|
id::String
|
|
text
|
|
end
|
|
|
|
function footnote(stream::IO, block::MD)
|
|
withstream(stream) do
|
|
regex = r"^\[\^(\w+)\]:"
|
|
str = startswith(stream, regex)
|
|
if isempty(str)
|
|
return false
|
|
else
|
|
ref = match(regex, str).captures[1]
|
|
buffer = IOBuffer()
|
|
write(buffer, readline(stream, chomp=false))
|
|
while !eof(stream)
|
|
if startswith(stream, " ")
|
|
write(buffer, readline(stream, chomp=false))
|
|
elseif blankline(stream)
|
|
write(buffer, '\n')
|
|
else
|
|
break
|
|
end
|
|
end
|
|
content = parse(seekstart(buffer)).content
|
|
push!(block, Footnote(ref, content))
|
|
return true
|
|
end
|
|
end
|
|
end
|
|
|
|
# ––––––
|
|
# Quotes
|
|
# ––––––
|
|
|
|
mutable struct BlockQuote
|
|
content
|
|
end
|
|
|
|
BlockQuote() = BlockQuote([])
|
|
|
|
# TODO: Laziness
|
|
@breaking true ->
|
|
function blockquote(stream::IO, block::MD)
|
|
withstream(stream) do
|
|
buffer = IOBuffer()
|
|
empty = true
|
|
while eatindent(stream) && startswith(stream, '>')
|
|
startswith(stream, " ")
|
|
write(buffer, readline(stream, chomp=false))
|
|
empty = false
|
|
end
|
|
empty && return false
|
|
|
|
md = String(take!(buffer))
|
|
push!(block, BlockQuote(parse(md, flavor = config(block)).content))
|
|
return true
|
|
end
|
|
end
|
|
|
|
# -----------
|
|
# Admonitions
|
|
# -----------
|
|
|
|
mutable struct Admonition
|
|
category::String
|
|
title::String
|
|
content::Vector
|
|
end
|
|
|
|
@breaking true ->
|
|
function admonition(stream::IO, block::MD)
|
|
withstream(stream) do
|
|
# Admonition syntax:
|
|
#
|
|
# !!! category "optional explicit title within double quotes"
|
|
# Any number of other indented markdown elements.
|
|
#
|
|
# This is the second paragraph.
|
|
#
|
|
startswith(stream, "!!! ") || return false
|
|
# Extract the category of admonition and its title:
|
|
category, title =
|
|
let untitled = r"^([a-z]+)$", # !!! <CATEGORY_NAME>
|
|
titled = r"^([a-z]+) \"(.*)\"$", # !!! <CATEGORY_NAME> "<TITLE>"
|
|
line = strip(readline(stream))
|
|
if ismatch(untitled, line)
|
|
m = match(untitled, line)
|
|
# When no title is provided we use CATEGORY_NAME, capitalising it.
|
|
m.captures[1], ucfirst(m.captures[1])
|
|
elseif ismatch(titled, line)
|
|
m = match(titled, line)
|
|
# To have a blank TITLE provide an explicit empty string as TITLE.
|
|
m.captures[1], m.captures[2]
|
|
else
|
|
# Admonition header is invalid so we give up parsing here and move
|
|
# on to the next parser.
|
|
return false
|
|
end
|
|
end
|
|
# Consume the following indented (4 spaces) block.
|
|
buffer = IOBuffer()
|
|
while !eof(stream)
|
|
if startswith(stream, " ")
|
|
write(buffer, readline(stream, chomp=false))
|
|
elseif blankline(stream)
|
|
write(buffer, '\n')
|
|
else
|
|
break
|
|
end
|
|
end
|
|
# Parse the nested block as markdown and create a new Admonition block.
|
|
nested = parse(String(take!(buffer)), flavor = config(block))
|
|
push!(block, Admonition(category, title, nested.content))
|
|
return true
|
|
end
|
|
end
|
|
|
|
# –––––
|
|
# Lists
|
|
# –––––
|
|
|
|
mutable struct List
|
|
items::Vector{Any}
|
|
ordered::Int # `-1` is unordered, `>= 0` is ordered.
|
|
|
|
List(x::AbstractVector, b::Integer) = new(x, b)
|
|
List(x::AbstractVector) = new(x, -1)
|
|
List(b::Integer) = new(Any[], b)
|
|
end
|
|
|
|
List(xs...) = List(vcat(xs...))
|
|
|
|
isordered(list::List) = list.ordered >= 0
|
|
|
|
const BULLETS = r"^ {0,3}(\*|\+|-)( |$)"
|
|
const NUM_OR_BULLETS = r"^ {0,3}(\*|\+|-|\d+(\.|\)))( |$)"
|
|
|
|
@breaking true ->
|
|
function list(stream::IO, block::MD)
|
|
withstream(stream) do
|
|
bullet = startswith(stream, NUM_OR_BULLETS; eat = false)
|
|
indent = isempty(bullet) ? (return false) : length(bullet)
|
|
# Calculate the starting number and regex to use for bullet matching.
|
|
initial, regex =
|
|
if ismatch(BULLETS, bullet)
|
|
# An unordered list. Use `-1` to flag the list as unordered.
|
|
-1, BULLETS
|
|
elseif ismatch(r"^ {0,3}\d+(\.|\))( |$)", bullet)
|
|
# An ordered list. Either with `1. ` or `1) ` style numbering.
|
|
r = contains(bullet, ".") ? r"^ {0,3}(\d+)\.( |$)" : r"^ {0,3}(\d+)\)( |$)"
|
|
Base.parse(Int, match(r, bullet).captures[1]), r
|
|
else
|
|
# Failed to match any bullets. This branch shouldn't actually be needed
|
|
# since the `NUM_OR_BULLETS` regex should cover this, but we include it
|
|
# simply for thoroughness.
|
|
return false
|
|
end
|
|
|
|
# Initialise the empty list object: either ordered or unordered.
|
|
list = List(initial)
|
|
|
|
buffer = IOBuffer() # For capturing nested text for recursive parsing.
|
|
newline = false # For checking if we have two consecutive newlines: end of list.
|
|
count = 0 # Count of list items. Used to check if we need to push remaining
|
|
# content in `buffer` after leaving the `while` loop.
|
|
while !eof(stream)
|
|
if startswith(stream, "\n")
|
|
if newline
|
|
# Double newline ends the current list.
|
|
pushitem!(list, buffer)
|
|
break
|
|
else
|
|
newline = true
|
|
println(buffer)
|
|
end
|
|
else
|
|
newline = false
|
|
if startswith(stream, " "^indent)
|
|
# Indented text that is part of the current list item.
|
|
print(buffer, readline(stream, chomp=false))
|
|
else
|
|
matched = startswith(stream, regex)
|
|
if isempty(matched)
|
|
# Unindented text meaning we have left the current list.
|
|
pushitem!(list, buffer)
|
|
break
|
|
else
|
|
# Start of a new list item.
|
|
count += 1
|
|
count > 1 && pushitem!(list, buffer)
|
|
print(buffer, readline(stream, chomp=false))
|
|
end
|
|
end
|
|
end
|
|
end
|
|
count == length(list.items) || pushitem!(list, buffer)
|
|
push!(block, list)
|
|
return true
|
|
end
|
|
end
|
|
pushitem!(list, buffer) = push!(list.items, parse(String(take!(buffer))).content)
|
|
|
|
# ––––––––––––––
|
|
# HorizontalRule
|
|
# ––––––––––––––
|
|
|
|
mutable struct HorizontalRule
|
|
end
|
|
|
|
function horizontalrule(stream::IO, block::MD)
|
|
withstream(stream) do
|
|
n, rule = 0, ' '
|
|
while !eof(stream)
|
|
char = read(stream, Char)
|
|
char == '\n' && break
|
|
isspace(char) && continue
|
|
if n==0 || char==rule
|
|
rule = char
|
|
n += 1
|
|
else
|
|
return false
|
|
end
|
|
end
|
|
is_hr = (n ≥ 3 && rule in "*-")
|
|
is_hr && push!(block, HorizontalRule())
|
|
return is_hr
|
|
end
|
|
end
|