refactor: simplify to_markdown function by removing post-processing argument and updating related calls

Author: yordis

lib/ex_doc/doc_ast.ex

@@ -67,81 +67,66 @@ defmodule ExDoc.DocAST do
 
   @doc """
   Transform AST into markdown string.
-
-  The optional `fun` argument allows post-processing each AST node
-  after it's been converted to markdown.
   """
-  def to_markdown(ast, fun \\ fn _ast, string -> string end)
+  def to_markdown(ast)
 
-  def to_markdown(binary, _fun) when is_binary(binary) do
+  def to_markdown(binary) when is_binary(binary) do
     ExDoc.Utils.h(binary)
   end
 
-  def to_markdown(list, fun) when is_list(list) do
-    result = Enum.map_join(list, "", &to_markdown(&1, fun))
-    fun.(list, result)
+  def to_markdown(list) when is_list(list) do
+    Enum.map_join(list, "", &to_markdown/1)
   end
 
-  def to_markdown({:comment, _attrs, inner, _meta} = ast, fun) do
-    fun.(ast, "<!--#{inner}-->")
+  def to_markdown({:comment, _attrs, inner, _meta}) do
+    "<!--#{inner}-->"
   end
 
-  def to_markdown({:code, attrs, inner, _meta} = ast, fun) do
+  def to_markdown({:code, attrs, inner, _meta}) do
     lang = attrs[:class] || ""
 
-    result = """
+    """
     ```#{lang}
     #{inner}
     ```
     """
-
-    fun.(ast, result)
   end
 
-  def to_markdown({:a, attrs, inner, _meta} = ast, fun) do
-    result = "[#{to_markdown(inner, fun)}](#{attrs[:href]})"
-    fun.(ast, result)
+  def to_markdown({:a, attrs, inner, _meta}) do
+    "[#{to_markdown(inner)}](#{attrs[:href]})"
   end
 
-  def to_markdown({:hr, _attrs, _inner, _meta} = ast, fun) do
-    result = "\n\n---\n\n"
-    fun.(ast, result)
+  def to_markdown({:hr, _attrs, _inner, _meta}) do
+    "\n\n---\n\n"
   end
 
-  def to_markdown({:p, _attrs, inner, _meta} = ast, fun) do
-    result = to_markdown(inner, fun) <> "\n\n"
-    fun.(ast, result)
+  def to_markdown({:p, _attrs, inner, _meta}) do
+    to_markdown(inner) <> "\n\n"
   end
 
-  def to_markdown({:br, _attrs, _inner, _meta} = ast, fun) do
-    result = "\n\n"
-    fun.(ast, result)
+  def to_markdown({:br, _attrs, _inner, _meta}) do
+    "\n\n"
   end
 
-  def to_markdown({:img, attrs, _inner, _meta} = ast, fun) do
+  def to_markdown({:img, attrs, _inner, _meta}) do
     alt = attrs[:alt] || ""
     title = attrs[:title] || ""
-    result = "![#{alt}](#{attrs[:src]} \"#{title}\")"
-    fun.(ast, result)
+    "![#{alt}](#{attrs[:src]} \"#{title}\")"
   end
 
   # ignoring these: area base col command embed input keygen link meta param source track wbr
-  def to_markdown({tag, _attrs, _inner, _meta} = ast, fun) when tag in @void_elements do
-    result = ""
-    fun.(ast, result)
+  def to_markdown({tag, _attrs, _inner, _meta}) when tag in @void_elements do
+    ""
   end
 
-  def to_markdown({_tag, _attrs, inner, %{verbatim: true}} = ast, fun) do
-    result = Enum.join(inner, "")
-    fun.(ast, result)
+  def to_markdown({_tag, _attrs, inner, %{verbatim: true}}) do
+    Enum.join(inner, "")
   end
 
-  def to_markdown({_tag, _attrs, inner, _meta} = ast, fun) do
-    result = to_markdown(inner, fun)
-    fun.(ast, result)
+  def to_markdown({_tag, _attrs, inner, _meta}) do
+    to_markdown(inner)
   end
 
-
   ## parse markdown
 
   defp parse_markdown(markdown, opts) do

lib/ex_doc/formatter/markdown.ex

@@ -114,7 +114,7 @@ defmodule ExDoc.Formatter.MARKDOWN do
     modules_info =
       nodes_map.modules
       |> Enum.map(fn module_node ->
-        "- **#{module_node.title}** (#{module_node.id}.md): #{module_node.doc |> extract_summary()}"
+        "- **#{module_node.title}** (#{module_node.id}.md): #{module_node.doc |> ExDoc.DocAST.synopsis() |> extract_plain_text()}"
       end)
       |> Enum.join("\n")
 
@@ -123,7 +123,7 @@ defmodule ExDoc.Formatter.MARKDOWN do
         tasks_list =
           nodes_map.tasks
           |> Enum.map(fn task_node ->
-            "- **#{task_node.title}** (#{task_node.id}.md): #{task_node.doc |> extract_summary()}"
+            "- **#{task_node.title}** (#{task_node.id}.md): #{task_node.doc |> ExDoc.DocAST.synopsis() |> extract_plain_text()}"
           end)
           |> Enum.join("\n")
 
@@ -157,55 +157,21 @@ defmodule ExDoc.Formatter.MARKDOWN do
     project_info <> modules_info <> tasks_info <> extras_info
   end
 
-  defp extract_summary(nil), do: "No documentation available"
-  defp extract_summary(""), do: "No documentation available"
-
-  defp extract_summary(doc) when is_binary(doc) do
-    doc
-    |> String.split("\n")
-    |> Enum.find("", fn line -> String.trim(line) != "" end)
+  defp extract_plain_text(html) when is_binary(html) do
+    html
+    |> String.replace(~r/<[^>]*>/, "")
+    |> String.replace(~r/\s+/, " ")
     |> String.trim()
     |> case do
       "" ->
         "No documentation available"
 
-      summary ->
-        summary
+      text ->
+        text
         |> String.slice(0, 150)
         |> then(fn s -> if String.length(s) == 150, do: s <> "...", else: s end)
     end
   end
 
-  defp extract_summary(doc_ast) when is_list(doc_ast) do
-    # For DocAST (which is a list), extract the first text node
-    extract_first_text_from_ast(doc_ast)
-  end
-
-  defp extract_summary(_), do: "No documentation available"
-
-  defp extract_first_text_from_ast([]), do: "No documentation available"
-
-  defp extract_first_text_from_ast([{:p, _, content} | _rest]) do
-    extract_text_from_content(content)
-    |> String.slice(0, 150)
-    |> then(fn s -> if String.length(s) == 150, do: s <> "...", else: s end)
-  end
-
-  defp extract_first_text_from_ast([_node | rest]) do
-    extract_first_text_from_ast(rest)
-  end
-
-  defp extract_text_from_content([]), do: ""
-  defp extract_text_from_content([text | _rest]) when is_binary(text), do: text
-
-  defp extract_text_from_content([{_tag, _attrs, content} | rest]) do
-    case extract_text_from_content(content) do
-      "" -> extract_text_from_content(rest)
-      text -> text
-    end
-  end
-
-  defp extract_text_from_content([_node | rest]) do
-    extract_text_from_content(rest)
-  end
+  defp extract_plain_text(_), do: "No documentation available"
 end