Merge pull request #65 from alfredbaudisch/toc-tree

HTML Header Table of Contents nesting, closes #64, closes alfredbaudisch/pardall_markdown_phoenix_demo#3

Author: alfredbaudisch

lib/pardall_markdown/content/html_utils.ex

@@ -101,8 +101,8 @@ defmodule PardallMarkdown.Content.HtmlUtils do
   def generate_anchors_and_toc(html, %{slug: slug}) do
     {updated_tree, %{toc: toc}} =
       Floki.parse_fragment!(html)
-      |> Floki.traverse_and_update(%{counters: %{}, toc: []}, fn
-        {"h" <> level, attrs, children} = el, acc ->
+      |> Floki.traverse_and_update(%{counters: %{}, toc: [], toc_positions: %{}}, fn
+        {"h" <> header_level, attrs, children} = el, acc ->
           case find_node_text(children) do
             nil ->
               {el, acc}
@@ -123,17 +123,23 @@ defmodule PardallMarkdown.Content.HtmlUtils do
                    {"data-title", title}
                  ], []}
 
-              toc_item = %{
+              int_header_level = parse_header_level(header_level)
+              {:level, level, :positions, positions} =
+                get_toc_level(acc.toc, int_header_level, acc.toc_positions)
+
+              link = %{
                 id: link_id,
+                level: level,
+                header: int_header_level,
                 parent_slug: slug,
-                title: title,
-                level: get_level_for_toc(acc[:toc], level)
+                title: title
               }
 
               acc = put_in(acc[:counters][id], increase_id_count(count))
-              acc = put_in(acc[:toc], acc.toc ++ [toc_item])
+              acc = put_in(acc[:toc], acc.toc ++ [link])
+              acc = put_in(acc[:toc_positions], positions)
 
-              {{"h" <> level, attrs, [anchor | children]}, acc}
+              {{"h" <> header_level, attrs, [anchor | children]}, acc}
           end
 
         el, acc ->
@@ -143,8 +149,47 @@ defmodule PardallMarkdown.Content.HtmlUtils do
     {:ok, updated_tree |> Floki.raw_html(), toc}
   end
 
-  defp get_level_for_toc([], _), do: 1
-  defp get_level_for_toc(_, level), do: level |> String.to_integer()
+  defp get_toc_level([], header, _), do:
+    {:level, 1, :positions, %{level: 1, header: header, index: 0}}
+
+  defp get_toc_level(_, header, %{level: curr_level, header: curr_header, index: idx})
+  when header == curr_header, do:
+    {:level, curr_level, :positions, %{level: curr_level, header: curr_header, index: idx + 1}}
+
+  defp get_toc_level(toc, header, %{level: curr_level, header: curr_header, index: idx})
+  when header < curr_header do
+    [_|reversed_toc] = toc |> Enum.reverse()
+
+    {_, level} =
+      reversed_toc
+      |> Enum.reduce({curr_header, curr_level}, fn
+        _, {acc_header, _} = acc
+        when acc_header <= header ->
+          acc
+
+        %{header: i_header, level: i_level}, _acc
+        when i_header < header ->
+          {i_header, i_level + 1}
+
+        %{header: i_header, level: i_level}, _acc
+        when i_header == header ->
+          {i_header, i_level}
+
+        %{header: i_header}, acc
+        when i_header > header ->
+          acc
+      end)
+
+    {:level, level, :positions, %{level: level, header: header, index: idx + 1}}
+  end
+
+  defp get_toc_level(_, header, %{level: curr_level, header: curr_header, index: idx})
+  when header > curr_header do
+    level = curr_level + 1
+    {:level, level, :positions, %{level: level, header: header, index: idx + 1}}
+  end
+
+  defp parse_header_level(level), do: String.to_integer(level)
 
   def strip_in_between_space(html),
     do:

lib/pardall_markdown/utils/struct_utils.ex

@@ -0,0 +1,28 @@
+defmodule PardallMarkdown.Utils.StructUtils do
+  def struct_to_map([]), do: []
+
+  def struct_to_map([_h|_t] = list) do
+    Enum.map(list, &struct_to_map/1)
+  end
+
+  def struct_to_map(item) when is_struct(item) do
+    item
+    |> Map.from_struct()
+    |> navigate_item()
+  end
+
+  def struct_to_map(item) when is_map(item) do
+    item
+    |> navigate_item()
+  end
+
+  defp navigate_item(item) do
+    item
+    |> Enum.map(fn
+      {k, v} when is_list(v) ->
+        {k, v |> struct_to_map()}
+      {k, v} -> {k, v}
+    end)
+    |> Enum.into(%{})
+  end
+end