Pass in msgctxt for config translation strings

lib/pleroma/docs/translator/compiler.ex

@@ -17,9 +17,15 @@ def placeholder do
         unquote do
           Enum.map(
             strings,
-            fn string ->
+            fn {path, type, string} ->
+              ctxt = msgctxt_for(path, type)
+
               quote do
-                Pleroma.Web.Gettext.dgettext_noop("config_descriptions", unquote(string))
+                Pleroma.Web.Gettext.dpgettext_noop(
+                  "config_descriptions",
+                  unquote(ctxt),
+                  unquote(string)
+                )
               end
             end
           )
@@ -36,7 +42,8 @@ def descriptions do
 
   def extract_strings(descriptions) do
     descriptions
-    |> Enum.reduce([], &process_item/2)
+    |> Enum.reduce(%{strings: [], path: []}, &process_item/2)
+    |> Map.get(:strings)
   end
 
   defp process_item(entity, acc) do
@@ -48,28 +55,65 @@ defp process_item(entity, acc) do
     process_children(entity, current_level)
   end
 
-  defp process_desc(acc, %{description: desc}) do
-    [desc | acc]
+  defp process_desc(acc, %{description: desc} = item) do
+    %{
+      strings: [{acc.path ++ [key_for(item)], "description", desc} | acc.strings],
+      path: acc.path
+    }
   end
 
   defp process_desc(acc, _) do
     acc
   end
 
-  defp process_label(acc, %{label: label}) do
-    [label | acc]
+  defp process_label(acc, %{label: label} = item) do
+    %{
+      strings: [{acc.path ++ [key_for(item)], "label", label} | acc.strings],
+      path: acc.path
+    }
   end
 
   defp process_label(acc, _) do
     acc
   end
 
-  defp process_children(%{children: children}, acc) do
+  defp process_children(%{children: children} = item, acc) do
+    current_level = Map.put(acc, :path, acc.path ++ [key_for(item)])
+
     children
-    |> Enum.reduce(acc, &process_item/2)
+    |> Enum.reduce(current_level, &process_item/2)
+    |> Map.put(:path, acc.path)
   end
 
   defp process_children(_, acc) do
     acc
   end
+
+  def msgctxt_for(path, type) do
+    "config #{type} at #{Enum.join(path, " > ")}"
+  end
+
+  defp convert_group({_, group}) do
+    group
+  end
+
+  defp convert_group(group) do
+    group
+  end
+
+  def key_for(%{group: group, key: key}) do
+    "#{convert_group(group)}-#{key}"
+  end
+
+  def key_for(%{group: group}) do
+    convert_group(group)
+  end
+
+  def key_for(%{key: key}) do
+    key
+  end
+
+  def key_for(_) do
+    nil
+  end
 end

lib/pleroma/web/admin_api/controllers/config_controller.ex

@@ -22,35 +22,51 @@ defmodule Pleroma.Web.AdminAPI.ConfigController do
 
   defdelegate open_api_operation(action), to: Pleroma.Web.ApiSpec.Admin.ConfigOperation
 
-  defp translate_descriptions(descriptions) do
-    Enum.map(descriptions, &translate_item/1)
+  defp translate_descriptions(descriptions, path \\ []) do
+    Enum.map(descriptions, fn desc -> translate_item(desc, path) end)
   end
 
-  defp translate_string(str) do
-    Gettext.dgettext(Pleroma.Web.Gettext, "config_descriptions", str)
+  defp translate_string(str, path, type) do
+    Gettext.dpgettext(
+      Pleroma.Web.Gettext,
+      "config_descriptions",
+      Pleroma.Docs.Translator.Compiler.msgctxt_for(path, type),
+      str
+    )
   end
 
-  defp maybe_put_translated(item, key) do
+  defp maybe_put_translated(item, key, path) do
     if item[key] do
-      Map.put(item, key, translate_string(item[key]))
+      Map.put(
+        item,
+        key,
+        translate_string(
+          item[key],
+          path ++ [Pleroma.Docs.Translator.Compiler.key_for(item)],
+          to_string(key)
+        )
+      )
     else
       item
     end
   end
 
-  defp translate_item(item) do
+  defp translate_item(item, path) do
     item
-    |> maybe_put_translated(:label)
-    |> maybe_put_translated(:description)
-    |> translate_children()
+    |> maybe_put_translated(:label, path)
+    |> maybe_put_translated(:description, path)
+    |> translate_children(path)
   end
 
-  defp translate_children(%{children: children} = item) when is_list(children) do
+  defp translate_children(%{children: children} = item, path) when is_list(children) do
     item
-    |> Map.put(:children, translate_descriptions(children))
+    |> Map.put(
+      :children,
+      translate_descriptions(children, path ++ [Pleroma.Docs.Translator.Compiler.key_for(item)])
+    )
   end
 
-  defp translate_children(item) do
+  defp translate_children(item, _path) do
     item
   end
 

test/pleroma/docs/translator/compiler_test.exs

@@ -9,30 +9,36 @@ defmodule Pleroma.Docs.Translator.CompilerTest do
 
   @descriptions [
     %{
+      key: "1",
       label: "1",
       description: "2",
       children: [
         %{
+          key: "3",
           label: "3",
           description: "4"
         },
         %{
+          key: "5",
           label: "5",
           description: "6"
         }
       ]
     },
     %{
+      key: "7",
       label: "7",
       description: "8",
       children: [
         %{
+          key: "9",
           description: "9",
           children: [
             %{
+              key: "10",
               description: "10",
               children: [
-                %{description: "11"},
+                %{key: "11", description: "11"},
                 %{description: "12"}
               ]
             }
@@ -42,14 +48,43 @@ defmodule Pleroma.Docs.Translator.CompilerTest do
           label: "13"
         }
       ]
+    },
+    %{
+      group: "14",
+      label: "14"
+    },
+    %{
+      group: "15",
+      key: "15",
+      label: "15"
+    },
+    %{
+      group: {":subgroup", "16"},
+      label: "16"
     }
   ]
 
   describe "extract_strings/1" do
     test "it extracts all labels and descriptions" do
       strings = Compiler.extract_strings(@descriptions)
-      assert length(strings) == 13
-      assert Enum.all?(1..13, &(to_string(&1) in strings))
+      assert length(strings) == 16
+
+      assert {["1"], "label", "1"} in strings
+      assert {["1"], "description", "2"} in strings
+      assert {["1", "3"], "label", "3"} in strings
+      assert {["1", "3"], "description", "4"} in strings
+      assert {["1", "5"], "label", "5"} in strings
+      assert {["1", "5"], "description", "6"} in strings
+      assert {["7"], "label", "7"} in strings
+      assert {["7"], "description", "8"} in strings
+      assert {["7", "9"], "description", "9"} in strings
+      assert {["7", "9", "10"], "description", "10"} in strings
+      assert {["7", "9", "10", "11"], "description", "11"} in strings
+      assert {["7", "9", "10", nil], "description", "12"} in strings
+      assert {["7", nil], "label", "13"} in strings
+      assert {["14"], "label", "14"} in strings
+      assert {["15-15"], "label", "15"} in strings
+      assert {["16"], "label", "16"} in strings
     end
   end
 end