1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
|
defmodule ExDoc.Markdown.Earmark do
@moduledoc """
ExDoc extension for the EarmarkParser Markdown parser.
"""
@behaviour ExDoc.Markdown
@admonition_classes ~w(warning error info tip neutral)
@impl true
def available? do
match?({:ok, _}, Application.ensure_all_started(:earmark_parser)) and
Code.ensure_loaded?(EarmarkParser)
end
@doc """
Generate HTML AST.
## Options
* `:gfm` - (boolean) turns on Github Flavored Markdown extensions. Defaults to `true`.
* `:breaks` - (boolean) only applicable if `gfm` is enabled. Makes all line
breaks significant (so every line in the input is a new line in the output).
"""
@impl true
def to_ast(text, opts) do
options = [
gfm: true,
line: 1,
file: "nofile",
breaks: false,
pure_links: true,
math: true
]
options = Keyword.merge(options, opts)
case EarmarkParser.as_ast(text, options) do
{:ok, ast, messages} ->
print_messages(messages, options)
fixup(ast)
{:error, ast, messages} ->
print_messages(messages, options)
fixup(ast)
end
end
defp print_messages(messages, options) do
for {_severity, line, message} <- messages do
ExDoc.Utils.warn(message, file: options[:file], line: line)
end
end
defp fixup(list) when is_list(list) do
fixup_list(list, [])
end
defp fixup(binary) when is_binary(binary) do
binary
end
defp fixup({tag, attrs, ast}) do
fixup({tag, attrs, ast, %{}})
end
# Rewrite math back to the original syntax, it's up to the user to render it
defp fixup({"code", [{"class", "math-inline"}], [content], _}) do
"$#{content}$"
end
defp fixup({"code", [{"class", "math-display"}], [content], _}) do
"$$\n#{content}\n$$"
end
# Convert admonition blockquotes to sections for screen reader accessibility
defp fixup(
{"blockquote", blockquote_attrs, [{tag, h_attrs, h_content, h_meta} | rest] = ast,
blockquote_meta}
)
when tag in ["h3", "h4"] do
h_admonition =
with {{"class", classes}, attrs} <- List.keytake(h_attrs, "class", 0),
class_list <- String.split(classes, " "),
adm_classes = [_ | _] <- Enum.filter(class_list, &(&1 in @admonition_classes)) do
{"admonition " <> Enum.join(adm_classes, " "),
[{"class", "admonition-title #{classes}"} | attrs]}
else
_ -> nil
end
section_attrs_fn = fn admonition_classes ->
{classes, attrs} =
case List.keytake(blockquote_attrs, "class", 0) do
nil ->
{admonition_classes, blockquote_attrs}
{{"class", classes}, attrs} ->
{"#{admonition_classes} #{classes}", attrs}
end
[{"role", "note"}, {"class", classes} | attrs]
end
if h_admonition do
{admonition_classes, h_attrs} = h_admonition
section_attrs = section_attrs_fn.(admonition_classes)
h_elem = {tag, h_attrs, h_content, h_meta}
fixup({"section", section_attrs, [h_elem | rest], blockquote_meta})
else
# regular blockquote, copied fixup/1 here to avoid infinite loop
{:blockquote, Enum.map(blockquote_attrs, &fixup_attr/1), fixup(ast), blockquote_meta}
end
end
defp fixup({tag, attrs, ast, meta}) when is_binary(tag) and is_list(attrs) and is_map(meta) do
{fixup_tag(tag), Enum.map(attrs, &fixup_attr/1), fixup(ast), meta}
end
defp fixup({:comment, _, _, _} = comment) do
comment
end
# We are matching on Livebook outputs here, because we prune comments at this point
defp fixup_list(
[
{:comment, _, [~s/ livebook:{"output":true} /], %{comment: true}},
{"pre", pre_attrs, [{"code", code_attrs, [source], code_meta}], pre_meta}
| ast
],
acc
) do
code_attrs =
case Enum.split_with(code_attrs, &match?({"class", _}, &1)) do
{[], attrs} -> [{"class", "output"} | attrs]
{[{"class", class}], attrs} -> [{"class", "#{class} output"} | attrs]
end
code_node = {"code", code_attrs, [source], code_meta}
fixup_list([{"pre", pre_attrs, [code_node], pre_meta} | ast], acc)
end
defp fixup_list([head | tail], acc) do
fixed = fixup(head)
if fixed == [] do
fixup_list(tail, acc)
else
fixup_list(tail, [fixed | acc])
end
end
defp fixup_list([], acc) do
Enum.reverse(acc)
end
defp fixup_tag(tag) do
String.to_atom(tag)
end
defp fixup_attr({name, value}) do
{String.to_atom(name), value}
end
end
|
