Packages
ex_doc
0.25.0
0.40.3
0.40.2
0.40.1
0.40.0
0.39.3
0.39.2
0.39.1
0.39.0
0.38.4
0.38.3
0.38.2
0.38.1
0.38.0
0.37.3
0.37.2
0.37.1
0.37.0
0.37.0-rc.2
0.37.0-rc.1
0.37.0-rc.0
0.36.1
0.36.0
0.35.1
0.35.0
0.34.2
0.34.1
0.34.0
0.33.0
0.32.2
0.32.1
0.32.0
0.31.2
0.31.1
0.31.0
0.30.9
0.30.8
0.30.7
0.30.6
0.30.5
0.30.4
0.30.3
0.30.2
0.30.1
0.30.0
0.29.4
0.29.3
0.29.2
0.29.1
0.29.0
0.28.6
0.28.5
0.28.4
0.28.3
0.28.2
0.28.1
0.28.0
0.27.3
0.27.2
0.27.1
0.27.0
0.26.0
0.25.5
0.25.4
0.25.3
0.25.2
0.25.1
0.25.0
0.24.2
0.24.1
0.24.0
0.23.0
0.22.6
0.22.5
0.22.4
0.22.2
0.22.1
0.22.0
0.21.3
0.21.2
0.21.1
0.21.0
0.20.2
0.20.1
0.20.0
0.19.3
0.19.2
0.19.1
0.19.0
0.19.0-rc
0.18.4
0.18.3
0.18.2
0.18.1
0.18.0
retired
0.17.1
0.17.0
retired
0.16.4
0.16.3
0.16.2
0.16.1
0.16.0
0.15.1
0.15.0
0.14.5
0.14.4
0.14.3
0.14.2
0.14.1
0.14.0
0.13.2
0.13.1
0.13.0
0.12.0
0.11.5
0.11.4
0.11.3
0.11.2
0.11.1
0.11.0
0.10.0
0.9.0
0.8.4
0.8.3
0.8.2
0.8.1
0.8.0
0.7.3
0.7.2
0.7.1
0.7.0
0.6.2
0.6.1
0.6.0
0.5.2
0.5.1
ExDoc is a documentation generation tool for Elixir
Current section
Files
Jump to
Current section
Files
lib/ex_doc/doc_ast.ex
defmodule ExDoc.DocAST do
@moduledoc false
@type t :: term()
alias ExDoc.Markdown
alias ExDoc.Formatter.HTML.Templates
@doc """
Parses given `doc_content` according to `doc_format`.
"""
def parse!(doc_content, doc_format, options \\ [])
def parse!(markdown, "text/markdown", opts) do
parse_markdown(markdown, opts)
end
def parse!(ast, "application/erlang+html", _options) do
parse_erl_ast(ast)
end
def parse!(_ast, other, _opts) do
raise "content type #{inspect(other)} is not supported"
end
# https://www.w3.org/TR/2011/WD-html-markup-20110113/syntax.html#void-element
@void_elements ~W(area base br col command embed hr img input keygen link
meta param source track wbr)a
@doc """
Transform AST into string.
"""
def to_string(ast, fun \\ fn _ast, string -> string end)
def to_string(binary, _fun) when is_binary(binary) do
Templates.h(binary)
end
def to_string(list, fun) when is_list(list) do
result = Enum.map_join(list, "", &to_string(&1, fun))
fun.(list, result)
end
def to_string({tag, attrs, _inner, _meta} = ast, fun) when tag in @void_elements do
result = "<#{tag}#{ast_attributes_to_string(attrs)}/>"
fun.(ast, result)
end
def to_string({tag, attrs, inner, %{verbatim: true}} = ast, fun) do
inner = Enum.join(inner, "")
result = "<#{tag}#{ast_attributes_to_string(attrs)}>" <> inner <> "</#{tag}>"
fun.(ast, result)
end
def to_string({tag, attrs, inner, _meta} = ast, fun) do
result = "<#{tag}#{ast_attributes_to_string(attrs)}>" <> to_string(inner, fun) <> "</#{tag}>"
fun.(ast, result)
end
defp ast_attributes_to_string(attrs) do
Enum.map(attrs, fn {key, val} -> " #{key}=\"#{val}\"" end)
end
## parse markdown
defp parse_markdown(markdown, opts) do
Markdown.to_ast(markdown, opts)
end
## parse erlang+html
defp parse_erl_ast(binary) when is_binary(binary) do
binary
end
defp parse_erl_ast(list) when is_list(list) do
Enum.map(list, &parse_erl_ast/1)
end
defp parse_erl_ast({:pre, attrs, content}) do
case content do
# if we already have <pre><code>...</code></pre>, carry on
[{:code, _, _}] ->
{:pre, attrs, parse_erl_ast(content), %{}}
# otherwise, turn <pre>...</pre> into <pre><code>...</code></pre>
_ ->
content = [{:code, [], parse_erl_ast(content), %{}}]
{:pre, attrs, content, %{}}
end
end
defp parse_erl_ast({tag, attrs, content}) when is_atom(tag) do
{tag, attrs, parse_erl_ast(content), %{}}
end
@doc """
Highlights a DocAST converted to string.
"""
def highlight(html, language, opts \\ []) do
highlight_info = language.highlight_info()
Regex.replace(
~r/<pre><code(?:\s+class="(\w*)")?>([^<]*)<\/code><\/pre>/,
html,
&highlight_code_block(&1, &2, &3, highlight_info, opts)
)
end
defp highlight_code_block(full_block, lang, code, highlight_info, outer_opts) do
case pick_language_and_lexer(lang, highlight_info) do
{_language, nil, _opts} -> full_block
{language, lexer, opts} -> render_code(language, lexer, opts, code, outer_opts)
end
end
defp pick_language_and_lexer("", highlight_info) do
{highlight_info.language_name, highlight_info.lexer, highlight_info.opts}
end
defp pick_language_and_lexer(lang, _highlight_info) do
case Makeup.Registry.fetch_lexer_by_name(lang) do
{:ok, {lexer, opts}} -> {lang, lexer, opts}
:error -> {lang, nil, []}
end
end
defp render_code(lang, lexer, lexer_opts, code, opts) do
highlight_tag = Keyword.get(opts, :highlight_tag, "span")
highlighted =
code
|> unescape_html()
|> IO.iodata_to_binary()
|> Makeup.highlight_inner_html(
lexer: lexer,
lexer_options: lexer_opts,
formatter_options: [highlight_tag: highlight_tag]
)
~s(<pre><code class="makeup #{lang}">#{highlighted}</code></pre>)
end
entities = [{"&", ?&}, {"<", ?<}, {">", ?>}, {""", ?"}, {"'", ?'}]
for {encoded, decoded} <- entities do
defp unescape_html(unquote(encoded) <> rest) do
[unquote(decoded) | unescape_html(rest)]
end
end
defp unescape_html(<<c, rest::binary>>) do
[c | unescape_html(rest)]
end
defp unescape_html(<<>>) do
[]
end
end