X-Git-Url: http://git.squeep.com/?a=blobdiff_plain;f=lib%2Fpleroma%2Fconfig%2Fconfig_db.ex;h=4097ee5b75cbe7ea6a58a7f00a1e36714f47d952;hb=d9f8941dac983d89709645831b41e02adc454740;hp=85a049f8a00d8907d20f1ffe3d00eae2a9f0b534;hpb=e69986169095796f2845c4f859234d96f91bf9ff;p=akkoma

diff --git a/lib/pleroma/config/config_db.ex b/lib/pleroma/config/config_db.ex
index 85a049f8a..4097ee5b7 100644
--- a/lib/pleroma/config/config_db.ex
+++ b/lib/pleroma/config/config_db.ex
@@ -1,17 +1,41 @@
 # Pleroma: A lightweight social networking server
-# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
+# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
 # SPDX-License-Identifier: AGPL-3.0-only
 
 defmodule Pleroma.ConfigDB do
   use Ecto.Schema
+
   import Ecto.Changeset
   import Ecto.Query
   import Pleroma.Web.Gettext
+
   alias __MODULE__
   alias Pleroma.Repo
 
   @type t :: %__MODULE__{}
 
+  @full_key_update [
+    {:pleroma, :ecto_repos},
+    {:quack, :meta},
+    {:mime, :types},
+    {:cors_plug, [:max_age, :methods, :expose, :headers]},
+    {:auto_linker, :opts},
+    {:swarm, :node_blacklist},
+    {:logger, :backends}
+  ]
+
+  @full_subkey_update [
+    {:pleroma, :assets, :mascots},
+    {:pleroma, :emoji, :groups},
+    {:pleroma, :workers, :retries},
+    {:pleroma, :mrf_subchain, :match_actor},
+    {:pleroma, :mrf_keyword, :replace}
+  ]
+
+  @regex ~r/^~r(?'delimiter'[\/|"'([{<]{1})(?'pattern'.+)[\/|"')\]}>]{1}(?'modifier'[uismxfU]*)/u
+
+  @delimiters ["/", "|", "\"", "'", {"(", ")"}, {"[", "]"}, {"{", "}"}, {"<", ">"}]
+
   schema "config" do
     field(:key, :string)
     field(:group, :string)
@@ -78,37 +102,35 @@ defmodule Pleroma.ConfigDB do
     end
   end
 
-  @full_subkey_update [
-    {:pleroma, :assets, :mascots},
-    {:pleroma, :emoji, :groups},
-    {:pleroma, :workers, :retries},
-    {:pleroma, :mrf_subchain, :match_actor},
-    {:pleroma, :mrf_keyword, :replace}
-  ]
-
-  @spec deep_merge(atom(), atom(), keyword(), keyword()) :: keyword()
-  def deep_merge(group, key, old_value, new_value) do
-    old_keys =
-      old_value
-      |> Keyword.keys()
-      |> MapSet.new()
-
-    new_keys =
-      new_value
-      |> Keyword.keys()
-      |> MapSet.new()
+  @spec merge_group(atom(), atom(), keyword(), keyword()) :: keyword()
+  def merge_group(group, key, old_value, new_value) do
+    new_keys = to_map_set(new_value)
 
-    intersect_keys = old_keys |> MapSet.intersection(new_keys) |> MapSet.to_list()
+    intersect_keys =
+      old_value |> to_map_set() |> MapSet.intersection(new_keys) |> MapSet.to_list()
 
-    subkeys = sub_key_full_update(group, key, intersect_keys)
+    merged_value = ConfigDB.merge(old_value, new_value)
 
-    merged_value = DeepMerge.deep_merge(old_value, new_value)
+    @full_subkey_update
+    |> Enum.map(fn
+      {g, k, subkey} when g == group and k == key ->
+        if subkey in intersect_keys, do: subkey, else: []
 
-    Enum.reduce(subkeys, merged_value, fn subkey, acc ->
+      _ ->
+        []
+    end)
+    |> List.flatten()
+    |> Enum.reduce(merged_value, fn subkey, acc ->
       Keyword.put(acc, subkey, new_value[subkey])
     end)
   end
 
+  defp to_map_set(keyword) do
+    keyword
+    |> Keyword.keys()
+    |> MapSet.new()
+  end
+
   @spec sub_key_full_update?(atom(), atom(), [Keyword.key()]) :: boolean()
   def sub_key_full_update?(group, key, subkeys) do
     Enum.any?(@full_subkey_update, fn {g, k, subkey} ->
@@ -116,42 +138,25 @@ defmodule Pleroma.ConfigDB do
     end)
   end
 
-  defp sub_key_full_update(group, key, subkeys) do
-    Enum.map(@full_subkey_update, fn
-      {g, k, subkey} when g == group and k == key ->
-        if subkey in subkeys, do: subkey, else: []
-
-      _ ->
-        []
+  @spec merge(keyword(), keyword()) :: keyword()
+  def merge(config1, config2) when is_list(config1) and is_list(config2) do
+    Keyword.merge(config1, config2, fn _, app1, app2 ->
+      if Keyword.keyword?(app1) and Keyword.keyword?(app2) do
+        Keyword.merge(app1, app2, &deep_merge/3)
+      else
+        app2
+      end
     end)
-    |> List.flatten()
   end
 
-  @full_key_update [
-    {:pleroma, :ecto_repos},
-    {:quack, :meta},
-    {:mime, :types},
-    {:cors_plug, [:max_age, :methods, :expose, :headers]},
-    {:auto_linker, :opts},
-    {:swarm, :node_blacklist},
-    {:logger, :backends}
-  ]
-
-  defp only_full_update?(%ConfigDB{} = config) do
-    config_group = ConfigDB.from_string(config.group)
-    config_key = ConfigDB.from_string(config.key)
-
-    Enum.any?(@full_key_update, fn
-      {group, key} when is_list(key) ->
-        config_group == group and config_key in key
-
-      {group, key} ->
-        config_group == group and config_key == key
-    end)
+  defp deep_merge(_key, value1, value2) do
+    if Keyword.keyword?(value1) and Keyword.keyword?(value2) do
+      Keyword.merge(value1, value2, &deep_merge/3)
+    else
+      value2
+    end
   end
 
-  defp can_be_partially_updated?(%ConfigDB{} = config), do: not only_full_update?(config)
-
   @spec update_or_create(map()) :: {:ok, ConfigDB.t()} | {:error, Changeset.t()}
   def update_or_create(params) do
     search_opts = Map.take(params, [:group, :key])
@@ -163,7 +168,7 @@ defmodule Pleroma.ConfigDB do
          transformed_value <- do_transform(params[:value]),
          {:can_be_merged, true, config} <- {:can_be_merged, is_list(transformed_value), config},
          new_value <-
-           deep_merge(
+           merge_group(
              ConfigDB.from_string(config.group),
              ConfigDB.from_string(config.key),
              old_value,
@@ -179,7 +184,22 @@ defmodule Pleroma.ConfigDB do
     end
   end
 
-  @spec delete(map()) :: {:ok, ConfigDB.t()} | {:error, Changeset.t()} | {:ok, nil}
+  defp can_be_partially_updated?(%ConfigDB{} = config), do: not only_full_update?(config)
+
+  defp only_full_update?(%ConfigDB{} = config) do
+    config_group = ConfigDB.from_string(config.group)
+    config_key = ConfigDB.from_string(config.key)
+
+    Enum.any?(@full_key_update, fn
+      {group, key} when is_list(key) ->
+        config_group == group and config_key in key
+
+      {group, key} ->
+        config_group == group and config_key == key
+    end)
+  end
+
+  @spec delete(map()) :: {:ok, ConfigDB.t()} | {:error, Changeset.t()}
   def delete(params) do
     search_opts = Map.delete(params, :subkeys)
 
@@ -187,12 +207,15 @@ defmodule Pleroma.ConfigDB do
          {config, sub_keys} when is_list(sub_keys) <- {config, params[:subkeys]},
          old_value <- from_binary(config.value),
          keys <- Enum.map(sub_keys, &do_transform_string(&1)),
-         new_value <- Keyword.drop(old_value, keys) do
+         {:partial_remove, config, new_value} when new_value != [] <-
+           {:partial_remove, config, Keyword.drop(old_value, keys)} do
       ConfigDB.update(config, %{value: new_value})
     else
+      {:partial_remove, config, []} ->
+        Repo.delete(config)
+
       {config, nil} ->
         Repo.delete(config)
-        {:ok, nil}
 
       nil ->
         err =
@@ -213,15 +236,7 @@ defmodule Pleroma.ConfigDB do
   end
 
   @spec from_string(String.t()) :: atom() | no_return()
-  def from_string(":" <> entity), do: String.to_existing_atom(entity)
-
-  def from_string(entity) when is_binary(entity) do
-    if is_module_name?(entity) do
-      String.to_existing_atom("Elixir.#{entity}")
-    else
-      entity
-    end
-  end
+  def from_string(string), do: do_transform_string(string)
 
   @spec convert(any()) :: any()
   def convert(entity), do: do_convert(entity)
@@ -263,18 +278,22 @@ defmodule Pleroma.ConfigDB do
     }
   end
 
-  # TODO: will become useless after removing hackney
-  defp do_convert({:partial_chain, entity}), do: %{"tuple" => [":partial_chain", inspect(entity)]}
+  defp do_convert(entity) when is_tuple(entity) do
+    value =
+      entity
+      |> Tuple.to_list()
+      |> do_convert()
 
-  defp do_convert(entity) when is_tuple(entity),
-    do: %{"tuple" => do_convert(Tuple.to_list(entity))}
+    %{"tuple" => value}
+  end
 
-  defp do_convert(entity) when is_boolean(entity) or is_number(entity) or is_nil(entity),
-    do: entity
+  defp do_convert(entity) when is_boolean(entity) or is_number(entity) or is_nil(entity) do
+    entity
+  end
 
   defp do_convert(entity)
        when is_atom(entity) and entity in [:"tlsv1.1", :"tlsv1.2", :"tlsv1.3"] do
-    ":#{to_string(entity)}"
+    ":#{entity}"
   end
 
   defp do_convert(entity) when is_atom(entity), do: inspect(entity)
@@ -302,16 +321,6 @@ defmodule Pleroma.ConfigDB do
     {:proxy_url, {do_transform_string(type), parse_host(host), port}}
   end
 
-  # TODO: will become useless after removing hackney
-  defp do_transform(%{"tuple" => [":partial_chain", entity]}) do
-    {partial_chain, []} =
-      entity
-      |> String.replace(~r/[^\w|^{:,[|^,|^[|^\]^}|^\/|^\.|^"]^\s/, "")
-      |> Code.eval_string()
-
-    {:partial_chain, partial_chain}
-  end
-
   defp do_transform(%{"tuple" => entity}) do
     Enum.reduce(entity, {}, fn val, acc -> Tuple.append(acc, do_transform(val)) end)
   end
@@ -346,10 +355,9 @@ defmodule Pleroma.ConfigDB do
     end
   end
 
-  @delimiters ["/", "|", "\"", "'", {"(", ")"}, {"[", "]"}, {"{", "}"}, {"<", ">"}]
-
-  defp find_valid_delimiter([], _string, _),
-    do: raise(ArgumentError, message: "valid delimiter for Regex expression not found")
+  defp find_valid_delimiter([], _string, _) do
+    raise(ArgumentError, message: "valid delimiter for Regex expression not found")
+  end
 
   defp find_valid_delimiter([{leading, closing} = delimiter | others], pattern, regex_delimiter)
        when is_tuple(delimiter) do
@@ -368,11 +376,9 @@ defmodule Pleroma.ConfigDB do
     end
   end
 
-  @regex_parts ~r/^~r(?'delimiter'[\/|"'([{<]{1})(?'pattern'.+)[\/|"')\]}>]{1}(?'modifier'[uismxfU]*)/u
-
   defp do_transform_string("~r" <> _pattern = regex) do
     with %{"modifier" => modifier, "pattern" => pattern, "delimiter" => regex_delimiter} <-
-           Regex.named_captures(@regex_parts, regex),
+           Regex.named_captures(@regex, regex),
          {:ok, {leading, closing}} <- find_valid_delimiter(@delimiters, pattern, regex_delimiter),
          {result, _} <- Code.eval_string("~r#{leading}#{pattern}#{closing}#{modifier}") do
       result
@@ -391,7 +397,7 @@ defmodule Pleroma.ConfigDB do
 
   @spec is_module_name?(String.t()) :: boolean()
   def is_module_name?(string) do
-    Regex.match?(~r/^(Pleroma|Phoenix|Tesla|Quack|Ueberauth)\./, string) or
+    Regex.match?(~r/^(Pleroma|Phoenix|Tesla|Quack|Ueberauth|Swoosh)\./, string) or
       string in ["Oban", "Ueberauth", "ExSyslogger"]
   end
 end