zf

groups.ex (11000B)

---

 defmodule Makeup.Lexer.Groups do
   @moduledoc """
   Utilities to highlight groups of tokens on mouseover.
 
   The typical example is to highlight matching pairs of delimiters,
   such as parenthesis, angle brackets, etc.
   """
 
   defp make_match([] = _patterns, _varnames, rest_of_tokens_varname) do
     quote do
       unquote(Macro.var(rest_of_tokens_varname, __MODULE__))
     end
   end
 
   defp make_match([pattern | patterns], [varname | varnames], rest_of_tokens_varname) do
     var = Macro.var(varname, __MODULE__)
 
     quote do
       [
         unquote(pattern) = unquote(var)
         | unquote(make_match(patterns, varnames, rest_of_tokens_varname))
       ]
     end
   end
 
   defp put_group_ids([], _group_id_varname) do
     quote(do: [])
   end
 
   defp put_group_ids(tokens, group_id_varname) do
     group_id = Macro.var(group_id_varname, __MODULE__)
 
     for {ttype_varname, attr_varname, text_varname} <- tokens do
       ttype = Macro.var(ttype_varname, __MODULE__)
       attr = Macro.var(attr_varname, __MODULE__)
       text = Macro.var(text_varname, __MODULE__)
 
       quote do
         {
           unquote(ttype),
           Map.put(
             unquote(attr),
             # The Map key (an atom)
             unquote(group_id_varname),
             # The variable holding the value
             unquote(group_id)
           ),
           unquote(text)
         }
       end
     end
   end
 
   defp open_branch(stack_name, pattern, group_prefix_varname, group_nr_varname) do
     group_nr = Macro.var(group_nr_varname, __MODULE__)
     group_prefix = Macro.var(group_prefix_varname, __MODULE__)
     group_id = Macro.var(:group_id, __MODULE__)
     rest_of_tokens = Macro.var(:rest_of_tokens, __MODULE__)
 
     n = length(pattern)
 
     token_varnames = for i <- 1..n, do: String.to_atom("token__#{i}")
     ttype_varnames = for i <- 1..n, do: String.to_atom("ttype__#{i}")
     attr_varnames = for i <- 1..n, do: String.to_atom("attr__#{i}")
     text_varnames = for i <- 1..n, do: String.to_atom("text__#{i}")
     tokens_data = List.zip([token_varnames, ttype_varnames, attr_varnames, text_varnames])
 
     pattern_matches =
       for {token_varname, ttype_varname, attr_varname, text_varname} <- tokens_data do
         token = Macro.var(token_varname, __MODULE__)
         ttype = Macro.var(ttype_varname, __MODULE__)
         attr = Macro.var(attr_varname, __MODULE__)
         text = Macro.var(text_varname, __MODULE__)
 
         quote do
           {unquote(ttype), unquote(attr), unquote(text)} = unquote(token)
         end
       end
 
     tokens_pattern = make_match(pattern, token_varnames, :rest_of_tokens)
 
     tokens_for_result = List.zip([ttype_varnames, attr_varnames, text_varnames])
     head_tokens = put_group_ids(tokens_for_result, :group_id)
 
     quote do
       {stack, unquote(tokens_pattern)} ->
         new_group_nr = unquote(group_nr) + 1
         unquote(group_id) = unquote(group_prefix) <> "-" <> to_string(new_group_nr)
         unquote_splicing(pattern_matches)
         head_tokens = unquote(head_tokens)
         head_of_stack = {unquote(stack_name), new_group_nr}
         new_stack = [head_of_stack | stack]
         {new_stack, new_group_nr, head_tokens, unquote(rest_of_tokens)}
     end
   end
 
   defp close_branch(stack_name, pattern, group_prefix_varname, group_nr_varname) do
     group_nr = Macro.var(group_nr_varname, __MODULE__)
     group_prefix = Macro.var(group_prefix_varname, __MODULE__)
     group_id = Macro.var(:group_id, __MODULE__)
     rest_of_stack = Macro.var(:rest_of_stack, __MODULE__)
     rest_of_tokens = Macro.var(:rest_of_tokens, __MODULE__)
 
     n = length(pattern)
 
     token_varnames = for i <- 1..n, do: String.to_atom("token__#{i}")
     ttype_varnames = for i <- 1..n, do: String.to_atom("ttype__#{i}")
     attr_varnames = for i <- 1..n, do: String.to_atom("attr__#{i}")
     text_varnames = for i <- 1..n, do: String.to_atom("text__#{i}")
     tokens_data = List.zip([token_varnames, ttype_varnames, attr_varnames, text_varnames])
 
     pattern_matches =
       for {token_varname, ttype_varname, attr_varname, text_varname} <- tokens_data do
         token = Macro.var(token_varname, __MODULE__)
         ttype = Macro.var(ttype_varname, __MODULE__)
         attr = Macro.var(attr_varname, __MODULE__)
         text = Macro.var(text_varname, __MODULE__)
 
         quote do
           {unquote(ttype), unquote(attr), unquote(text)} = unquote(token)
         end
       end
 
     stack_pattern =
       quote do
         [{unquote(stack_name), current_group_nr} | unquote(rest_of_stack)]
       end
 
     tokens_pattern = make_match(pattern, token_varnames, :rest_of_tokens)
 
     tokens_for_result = List.zip([ttype_varnames, attr_varnames, text_varnames])
     head_tokens = put_group_ids(tokens_for_result, :group_id)
 
     quote do
       {unquote(stack_pattern), unquote(tokens_pattern)} ->
         unquote(group_id) = unquote(group_prefix) <> "-" <> to_string(current_group_nr)
         unquote_splicing(pattern_matches)
         head_tokens = unquote(head_tokens)
         {unquote(rest_of_stack), unquote(group_nr), head_tokens, unquote(rest_of_tokens)}
     end
   end
 
   defp middle_branch(stack_name, pattern, group_prefix_varname, group_nr_varname) do
     group_nr = Macro.var(group_nr_varname, __MODULE__)
 
     group_prefix = Macro.var(group_prefix_varname, __MODULE__)
     group_id = Macro.var(:group_id, __MODULE__)
     rest_of_stack = Macro.var(:rest_of_stack, __MODULE__)
     rest_of_tokens = Macro.var(:rest_of_tokens, __MODULE__)
 
     n = length(pattern)
 
     token_varnames = for i <- 1..n, do: String.to_atom("token__#{i}")
     ttype_varnames = for i <- 1..n, do: String.to_atom("ttype__#{i}")
     attr_varnames = for i <- 1..n, do: String.to_atom("attr__#{i}")
     text_varnames = for i <- 1..n, do: String.to_atom("text__#{i}")
     tokens_data = List.zip([token_varnames, ttype_varnames, attr_varnames, text_varnames])
 
     pattern_matches =
       for {token_varname, ttype_varname, attr_varname, text_varname} <- tokens_data do
         token = Macro.var(token_varname, __MODULE__)
         ttype = Macro.var(ttype_varname, __MODULE__)
         attr = Macro.var(attr_varname, __MODULE__)
         text = Macro.var(text_varname, __MODULE__)
 
         quote do
           {unquote(ttype), unquote(attr), unquote(text)} = unquote(token)
         end
       end
 
     stack_pattern =
       quote do
         [{unquote(stack_name), current_group_nr} | unquote(rest_of_stack)]
       end
 
     tokens_pattern = make_match(pattern, token_varnames, :rest_of_tokens)
 
     tokens_for_result = List.zip([ttype_varnames, attr_varnames, text_varnames])
     head_tokens = put_group_ids(tokens_for_result, :group_id)
 
     quote do
       {unquote(stack_pattern) = stack, unquote(tokens_pattern)} ->
         unquote(group_id) = unquote(group_prefix) <> "-" <> to_string(current_group_nr)
         unquote_splicing(pattern_matches)
         head_tokens = unquote(head_tokens)
         {stack, unquote(group_nr), head_tokens, unquote(rest_of_tokens)}
     end
   end
 
   defp branches_for_stack({stack_name, parts}) do
     open_patterns = Keyword.fetch!(parts, :open)
     middle_patterns = Keyword.get(parts, :middle, [])
     close_patterns = Keyword.fetch!(parts, :close)
 
     open_branches_ast =
       Enum.map(
         open_patterns,
         fn pattern -> open_branch(stack_name, pattern, :group_prefix, :group_nr) end
       )
 
     middle_branches_ast =
       Enum.map(
         middle_patterns,
         fn pattern -> middle_branch(stack_name, pattern, :group_prefix, :group_nr) end
       )
 
     close_branches_ast =
       Enum.map(
         close_patterns,
         fn pattern -> close_branch(stack_name, pattern, :group_prefix, :group_nr) end
       )
 
     open_branches_ast ++ middle_branches_ast ++ close_branches_ast
   end
 
   @doc """
   Defines a function with the given `name` that takes a list of tokens and divides
   matching delimiters into groups.
 
   Takes as arguments a `name` for the function (must be an atom) and a list
   containing the patterns describing the matching groups.
 
   ## Examples
 
       # Extracted from the default elixir lexer that ships with ExDoc
       defgroupmatcher :match_groups, [
         # Match opening and closing parenthesis
         parentheses: [
           open: [[{:punctuation, %{language: :elixir}, "("}]],
           close: [[{:punctuation, %{language: :elixir}, ")"}]]
         ],
 
         # Match more complex delimiters, but still an open and close delimiter
         fn_end: [
           open: [[{:keyword, %{language: :elixir}, "fn"}]],
           close: [[{:keyword, %{language: :elixir}, "end"}]]
         ]
 
         # Match delimiters with middle components
         do_end: [
           open: [
             [{:keyword, %{language: :elixir}, "do"}]
           ],
           middle: [
             [{:keyword, %{language: :elixir}, "else"}],
             [{:keyword, %{language: :elixir}, "catch"}],
             [{:keyword, %{language: :elixir}, "rescue"}],
             [{:keyword, %{language: :elixir}, "after"}]
           ],
           close: [
             [{:keyword, %{language: :elixir}, "end"}]
           ]
         ]
       ]
   """
   defmacro defgroupmatcher(name, stacks, opts \\ []) do
     name_helper =
       name
       |> Atom.to_string()
       |> Kernel.<>("__helper")
       |> String.to_atom()
 
     branches =
       stacks
       |> Enum.map(&branches_for_stack/1)
       |> List.flatten()
 
     group_nr = Macro.var(:group_nr, __MODULE__)
 
     unmatched_token_branch =
       quote do
         {old_stack, [token | toks]} ->
           {old_stack, unquote(group_nr), [token], toks}
       end
 
     no_more_tokens_branch =
       quote do
         {old_stack, []} ->
           {old_stack, unquote(group_nr), [], []}
       end
 
     all_branches = branches ++ unmatched_token_branch ++ no_more_tokens_branch
 
     expr =
       quote do
         def unquote(name)(tokens, group_prefix \\ "group") do
           unquote(name_helper)([], tokens, group_prefix, 0) |> :lists.flatten()
         end
 
         defp unquote(name_helper)(stack, tokens, group_prefix, group_nr) do
           {new_stack, new_group_nr, head_tokens, rest_of_tokens} =
             case {stack, tokens} do
               unquote(all_branches)
             end
 
           case head_tokens do
             [] ->
               []
 
             _ ->
               # Don't worry about the nested list, we'll flatten it later
               [
                 head_tokens
                 | unquote(name_helper)(new_stack, rest_of_tokens, group_prefix, new_group_nr)
               ]
           end
         end
       end
 
     if Keyword.get(opts, :debug) do
       expr
       |> Macro.to_string()
       |> Code.format_string!()
       |> IO.puts()
     end
 
     expr
   end
 
   @doc """
   Returns a random prefix for group ids in an HTML file.
 
   This is useful to avoid collisions.
   The group ids should be unique for a certain HTML document, and the easiest way of guaranteeing it
   is by generating long random prefixes.
   """
   def random_prefix(n), do: Enum.map(1..n, fn _ -> Enum.random(?0..?9) end) |> to_string
 end