How to extend Earmark

Questions / Help
1

I’d like to extend Earmark to transform #hashtag into

<a href="/some/internal/route">hashtag</a>

Hashtags should only be transformed if they are inside of a string node, so I need to inspect the AST.

I’ve been looking through the Earmark docs and I don’t see a clear way to do this. I don’t think I can use map_ast as it says a string node must return a string.

I’ve found one example of something similar here:

It looks like they using Enum.map on the ast, but I don’t fully understand the transform_ast_node_text function, particularly the bits that pattern match on binary data. I hope I can do something simpler.

Any help is appreciated, thanks!

2

This should not be too difficult

import Earmark.Transform
iex(11)> {:ok, ast,_} = EarmarkParser.as_ast(" #x")
{:ok, [{"p", [], [" #x"], %{}}], []}
iex(12)> transform = fn
...(12)> x when is_tuple(x) -> x
...(12)> _ -> [ " ", {"a", [{"href", "whatever"}], ["x"], %{}}] end # need to scan the parameter for hashtags and create a structure like the one I just put here
#Function<44.65746770/1 in :erl_eval.expr/5>
iex(13)> ast1 =map_ast(ast, transform)
[{"p", [], [[" ", {"a", [{"href", "whatever"}], ["x"], %{}}]], %{}}]
iex(14)> transform(ast1, [])
"<p>\n <a href=\"whatever\">x</a></p>\n"

HTH

1 Like
3

hey, thanks for the great work on Earmark!

I realized after posting this that I only want to transform text leafs that are descendants of certain tags. Otherwise I might inject an <a> tag inside of a <code> block for example. Here’s what I came up with if anyone is interested:

def parse_tags(text_leaf) when is_binary(text_leaf) do
  Regex.split(
    ~r/#([a-zA-Z0-9]{2,})/,
    text_leaf,
    include_captures: true
  )
  |> Enum.map(fn
    <<?#, tagname::binary>> ->
      {"a",
       [
         {"class", "tag"},
         {"href", "/board?tag=#{tagname}"}
       ], [tagname], %{}}

    text ->
      text
  end)
end

def map_ast(ast, text_is_eligible_for_hashtag \\ false) do
  Enum.map(ast, fn
    {tag, atts, children, m} ->
      {tag, atts, map_ast(children, tag in ["p", "li"]), m}

    text_leaf ->
      if text_is_eligible_for_hashtag, do: parse_tags(text_leaf), else: text_leaf
  end)
end

def markdown(md) do
  case EarmarkParser.as_ast(md) do
    {:ok, ast, _} -> map_ast(ast) |> Earmark.Transform.transform()
    _ -> md
  end
end
2 Likes
4

naturally :wink:

yeah I guess in these cases you have to do it yourself, would be an interesting idea to generalize,
many things come into mind, e.g. an option to parse with a callback function that adds things to the meta Map in the AST, or an AST walker that keeps access to the parent nodes, …

Unfortunately no time at all.

2 Likes
5

I just realized with the release of Earmark 1.4.25 there are two ways to achieve your goals with Earmarks tools at hand

even before 1.4.25 you could have used map_ast_with to keep track of the condition if to replace hashtags or not in the accumulator

and now from 1.4.25 you can also, which IMHO is more elegant, change the mapper function dynamically when traversing with map_ast by not returning a quadruple but a tuple with the new function and a quadruple

here
you can find an example of how to do that

1 Like