Nest module aliases

lib/ex_doc.ex

@@ -77,15 +77,46 @@ defmodule ExDoc do
       options[:source_url_pattern] ||
         guess_url(options[:source_url], options[:source_ref] || ExDoc.Config.default_source_ref())
 
-    options = Keyword.put(options, :source_url_pattern, pattern)
+    options
+    |> Keyword.put(:source_url_pattern, pattern)
+    |> normalize_output()
+    |> normalize_nest_module_aliases()
+  end
 
+  defp normalize_output(options) do
     if is_binary(options[:output]) do
       Keyword.put(options, :output, String.trim_trailing(options[:output], "/"))
     else
       options
     end
   end
 
+  defp normalize_nest_module_aliases(options) do
+    normalized_aliases =
+      options
+      |> Keyword.get(:nest_module_aliases)
+      |> Enum.map(&normalize_nest_module_alias/1)
+      |> Enum.into(%{})
+
+    Keyword.put(options, :nest_module_aliases, normalized_aliases)
+  end
+
+  defp normalize_nest_module_alias(module) when is_atom(module),
+    do: normalize_nest_module_alias({module, as: module})
+
+  defp normalize_nest_module_alias({module, keyword}) when is_atom(module) and is_list(keyword) do
+    alias_name = Keyword.fetch!(keyword, :as)
+
+    alias_name =
+      if is_binary(alias_name) do
+        alias_name
+      else
+        inspect(alias_name)
+      end
+
+    {inspect(module), alias_name}
+  end
+
   defp guess_url(url, ref) do
     with {:ok, host_with_path} <- http_or_https(url),
          {:ok, pattern} <- known_pattern(host_with_path, ref) do

lib/ex_doc/config.ex

@@ -32,6 +32,7 @@ defmodule ExDoc.Config do
             language: "en",
             logo: nil,
             main: nil,
+            nest_module_aliases: [],
             output: "./doc",
             project: nil,
             retriever: ExDoc.Retriever,
@@ -59,6 +60,7 @@ defmodule ExDoc.Config do
           language: String.t(),
           logo: nil | Path.t(),
           main: nil | String.t(),
+          nest_module_aliases: keyword() | list({atom, keyword}),
           groups_for_modules: keyword(),
           groups_for_functions: keyword((keyword() -> boolean)),
           output: nil | Path.t(),

lib/ex_doc/retriever.ex

@@ -109,6 +109,9 @@ defmodule ExDoc.Retriever do
     {title, id} = module_title_and_id(module_data)
     module_group = GroupMatcher.match_module(config.groups_for_modules, module, id)
 
+    module_aliases = Map.get(config, :nest_module_aliases)
+    {module_group, title} = apply_nested_module_aliases(module_group, title, module_aliases)
+
     %ExDoc.ModuleNode{
       id: id,
       title: title,
@@ -175,6 +178,35 @@ defmodule ExDoc.Retriever do
     end
   end
 
+  defp apply_nested_module_aliases(group_name, title, aliases) do
+    case truncate_if_aliased(title, aliases) do
+      {nil, title} ->
+        {group_name, title}
+
+      {prefix, unprefixed_title} ->
+        group_name =
+          if group_name == nil do
+            aliases
+            |> Map.get(prefix)
+            |> String.to_atom()
+          else
+            group_name
+          end
+
+        {group_name, unprefixed_title}
+    end
+  end
+
+  defp truncate_if_aliased(title, aliases) do
+    aliases
+    |> Map.keys()
+    |> Enum.find(&String.starts_with?(title, &1))
+    |> case do
+      nil -> {nil, title}
+      prefix -> {prefix, String.trim_leading(title, prefix <> ".")}
+    end
+  end
+
   ## Function helpers
 
   defp get_docs(%{type: type, docs: docs} = module_data, source, config) do