Merge remote-tracking branch 'remotes/origin/develop' into 1505-threads-federation

[akkoma] / lib / pleroma / docs / generator.ex

diff --git a/lib/pleroma/docs/generator.ex b/lib/pleroma/docs/generator.ex
index aa578eee280657f4a7bf9eb35016f58bfbc795e9..e0fc8cd02144de31766dbb22a204d1e53e7aa5d3 100644 (file)
--- a/lib/pleroma/docs/generator.ex
+++ b/lib/pleroma/docs/generator.ex
@@ -6,68 +6,116 @@ defmodule Pleroma.Docs.Generator do
     implementation.process(descriptions)
   end
 
-  @spec uploaders_list() :: [module()]
-  def uploaders_list do
-    {:ok, modules} = :application.get_key(:pleroma, :modules)
+  @spec list_modules_in_dir(String.t(), String.t()) :: [module()]
+  def list_modules_in_dir(dir, start) do
+    with {:ok, files} <- File.ls(dir) do
+      files
+      |> Enum.filter(&String.ends_with?(&1, ".ex"))
+      |> Enum.map(fn filename ->
+        module = filename |> String.trim_trailing(".ex") |> Macro.camelize()
+        String.to_atom(start <> module)
+      end)
+    end
+  end
+
+  @doc """
+  Converts:
+  - atoms to strings with leading `:`
+  - module names to strings, without leading `Elixir.`
+  - add humanized labels to `keys` if label is not defined, e.g. `:instance` -> `Instance`
+  """
+  @spec convert_to_strings([map()]) :: [map()]
+  def convert_to_strings(descriptions) do
+    Enum.map(descriptions, &format_entity(&1))
+  end
 
-    Enum.filter(modules, fn module ->
-      name_as_list = Module.split(module)
+  defp format_entity(entity) do
+    entity
+    |> format_key()
+    |> Map.put(:group, atom_to_string(entity[:group]))
+    |> format_children()
+  end
 
-      List.starts_with?(name_as_list, ["Pleroma", "Uploaders"]) and
-        List.last(name_as_list) != "Uploader"
-    end)
+  defp format_key(%{key: key} = entity) do
+    entity
+    |> Map.put(:key, atom_to_string(key))
+    |> Map.put(:label, entity[:label] || humanize(key))
   end
 
-  @spec filters_list() :: [module()]
-  def filters_list do
-    {:ok, modules} = :application.get_key(:pleroma, :modules)
+  defp format_key(%{group: group} = entity) do
+    Map.put(entity, :label, entity[:label] || humanize(group))
+  end
 
-    Enum.filter(modules, fn module ->
-      name_as_list = Module.split(module)
+  defp format_key(entity), do: entity
 
-      List.starts_with?(name_as_list, ["Pleroma", "Upload", "Filter"])
-    end)
+  defp format_children(%{children: children} = entity) do
+    Map.put(entity, :children, Enum.map(children, &format_child(&1)))
   end
 
-  @spec mrf_list() :: [module()]
-  def mrf_list do
-    {:ok, modules} = :application.get_key(:pleroma, :modules)
+  defp format_children(entity), do: entity
+
+  defp format_child(%{suggestions: suggestions} = entity) do
+    entity
+    |> Map.put(:suggestions, format_suggestions(suggestions))
+    |> format_key()
+    |> format_group()
+    |> format_children()
+  end
 
-    Enum.filter(modules, fn module ->
-      name_as_list = Module.split(module)
+  defp format_child(entity) do
+    entity
+    |> format_key()
+    |> format_group()
+    |> format_children()
+  end
 
-      List.starts_with?(name_as_list, ["Pleroma", "Web", "ActivityPub", "MRF"]) and
-        length(name_as_list) > 4
-    end)
+  defp format_group(%{group: group} = entity) do
+    Map.put(entity, :group, format_suggestion(group))
   end
 
-  @spec richmedia_parsers() :: [module()]
-  def richmedia_parsers do
-    {:ok, modules} = :application.get_key(:pleroma, :modules)
+  defp format_group(entity), do: entity
+
+  defp atom_to_string(entity) when is_binary(entity), do: entity
 
-    Enum.filter(modules, fn module ->
-      name_as_list = Module.split(module)
+  defp atom_to_string(entity) when is_atom(entity), do: inspect(entity)
 
-      List.starts_with?(name_as_list, ["Pleroma", "Web", "RichMedia", "Parsers"]) and
-        length(name_as_list) == 5
-    end)
+  defp humanize(entity) do
+    string = inspect(entity)
+
+    if String.starts_with?(string, ":"),
+      do: Phoenix.Naming.humanize(entity),
+      else: string
   end
+
+  defp format_suggestions([]), do: []
+
+  defp format_suggestions([suggestion | tail]) do
+    [format_suggestion(suggestion) | format_suggestions(tail)]
+  end
+
+  defp format_suggestion(entity) when is_atom(entity) do
+    atom_to_string(entity)
+  end
+
+  defp format_suggestion([head | tail] = entity) when is_list(entity) do
+    [format_suggestion(head) | format_suggestions(tail)]
+  end
+
+  defp format_suggestion(entity) when is_tuple(entity) do
+    format_suggestions(Tuple.to_list(entity)) |> List.to_tuple()
+  end
+
+  defp format_suggestion(entity), do: entity
 end
 
 defimpl Jason.Encoder, for: Tuple do
-  def encode(tuple, opts) do
-    Jason.Encode.list(Tuple.to_list(tuple), opts)
-  end
+  def encode(tuple, opts), do: Jason.Encode.list(Tuple.to_list(tuple), opts)
 end
 
 defimpl Jason.Encoder, for: [Regex, Function] do
-  def encode(term, opts) do
-    Jason.Encode.string(inspect(term), opts)
-  end
+  def encode(term, opts), do: Jason.Encode.string(inspect(term), opts)
 end
 
 defimpl String.Chars, for: Regex do
-  def to_string(term) do
-    inspect(term)
-  end
+  def to_string(term), do: inspect(term)
 end