Merge branch 'mrf-cleanup' into 'develop'

MRF cleanup

See merge request pleroma/pleroma!4219

lib/pleroma/web/activity_pub/mrf/anti_followbot_policy.ex

@@ -63,20 +63,20 @@ defmodule Pleroma.Web.ActivityPub.MRF.AntiFollowbotPolicy do
   end
 
   @impl true
-  def filter(%{"type" => "Follow", "actor" => actor_id} = message) do
+  def filter(%{"type" => "Follow", "actor" => actor_id} = activity) do
     %User{} = actor = normalize_by_ap_id(actor_id)
 
     score = determine_if_followbot(actor)
 
-    if score < 0.8 || bot_allowed?(message, actor) do
+    if score < 0.8 || bot_allowed?(activity, actor) do
-      {:ok, message}
+      {:ok, activity}
     else
       {:reject, "[AntiFollowbotPolicy] Scored #{actor_id} as #{score}"}
     end
   end
 
   @impl true
-  def filter(message), do: {:ok, message}
+  def filter(activity), do: {:ok, activity}
 
   @impl true
   def describe, do: {:ok, %{}}

lib/pleroma/web/activity_pub/mrf/anti_link_spam_policy.ex

@@ -29,17 +29,17 @@ defmodule Pleroma.Web.ActivityPub.MRF.AntiLinkSpamPolicy do
   defp contains_links?(_), do: false
 
   @impl true
-  def filter(%{"type" => "Create", "actor" => actor, "object" => object} = message) do
+  def filter(%{"type" => "Create", "actor" => actor, "object" => object} = activity) do
     with {:ok, %User{local: false} = u} <- User.get_or_fetch_by_ap_id(actor),
          {:contains_links, true} <- {:contains_links, contains_links?(object)},
          {:old_user, true} <- {:old_user, old_user?(u)} do
-      {:ok, message}
+      {:ok, activity}
     else
       {:ok, %User{local: true}} ->
-        {:ok, message}
+        {:ok, activity}
 
       {:contains_links, false} ->
-        {:ok, message}
+        {:ok, activity}
 
       {:old_user, false} ->
         {:reject, "[AntiLinkSpamPolicy] User has no posts nor followers"}
@@ -53,7 +53,7 @@ defmodule Pleroma.Web.ActivityPub.MRF.AntiLinkSpamPolicy do
   end
 
   # in all other cases, pass through
-  def filter(message), do: {:ok, message}
+  def filter(activity), do: {:ok, activity}
 
   @impl true
   def describe, do: {:ok, %{}}

lib/pleroma/web/activity_pub/mrf/anti_mention_spam_policy.ex

@@ -22,11 +22,11 @@ defmodule Pleroma.Web.ActivityPub.MRF.AntiMentionSpamPolicy do
   end
 
   # copied from HellthreadPolicy
-  defp get_recipient_count(message) do
+  defp get_recipient_count(activity) do
-    recipients = (message["to"] || []) ++ (message["cc"] || [])
+    recipients = (activity["to"] || []) ++ (activity["cc"] || [])
 
     follower_collection =
-      User.get_cached_by_ap_id(message["actor"] || message["attributedTo"]).follower_address
+      User.get_cached_by_ap_id(activity["actor"] || activity["attributedTo"]).follower_address
 
     if Enum.member?(recipients, Pleroma.Constants.as_public()) do
       recipients =
@@ -80,7 +80,7 @@ defmodule Pleroma.Web.ActivityPub.MRF.AntiMentionSpamPolicy do
   end
 
   # in all other cases, pass through
-  def filter(message), do: {:ok, message}
+  def filter(activity), do: {:ok, activity}
 
   @impl true
   def describe, do: {:ok, %{}}

lib/pleroma/web/activity_pub/mrf/dnsrbl_policy.ex

@@ -38,18 +38,18 @@ defmodule Pleroma.Web.ActivityPub.MRF.DNSRBLPolicy do
   @query_timeout 500
 
   @impl true
-  def filter(%{"actor" => actor} = object) do
+  def filter(%{"actor" => actor} = activity) do
     actor_info = URI.parse(actor)
 
-    with {:ok, object} <- check_rbl(actor_info, object) do
+    with {:ok, activity} <- check_rbl(actor_info, activity) do
-      {:ok, object}
+      {:ok, activity}
     else
       _ -> {:reject, "[DNSRBLPolicy]"}
     end
   end
 
   @impl true
-  def filter(object), do: {:ok, object}
+  def filter(activity), do: {:ok, activity}
 
   @impl true
   def describe do
@@ -90,7 +90,7 @@ defmodule Pleroma.Web.ActivityPub.MRF.DNSRBLPolicy do
     }
   end
 
-  defp check_rbl(%{host: actor_host}, object) do
+  defp check_rbl(%{host: actor_host}, activity) do
     with false <- match?(^actor_host, Pleroma.Web.Endpoint.host()),
          zone when not is_nil(zone) <- Keyword.get(Config.get([:mrf_dnsrbl]), :zone) do
       query =
@@ -100,7 +100,7 @@ defmodule Pleroma.Web.ActivityPub.MRF.DNSRBLPolicy do
       rbl_response = rblquery(query)
 
       if Enum.empty?(rbl_response) do
-        {:ok, object}
+        {:ok, activity}
       else
         Task.start(fn ->
           reason =
@@ -117,7 +117,7 @@ defmodule Pleroma.Web.ActivityPub.MRF.DNSRBLPolicy do
         :error
       end
     else
-      _ -> {:ok, object}
+      _ -> {:ok, activity}
     end
   end
 

lib/pleroma/web/activity_pub/mrf/drop_policy.ex

@@ -8,9 +8,9 @@ defmodule Pleroma.Web.ActivityPub.MRF.DropPolicy do
   @behaviour Pleroma.Web.ActivityPub.MRF.Policy
 
   @impl true
-  def filter(object) do
+  def filter(activity) do
-    Logger.debug("REJECTING #{inspect(object)}")
+    Logger.debug("REJECTING #{inspect(activity)}")
-    {:reject, object}
+    {:reject, activity}
   end
 
   @impl true

lib/pleroma/web/activity_pub/mrf/emoji_policy.ex

@@ -28,11 +28,11 @@ defmodule Pleroma.Web.ActivityPub.MRF.EmojiPolicy do
     Pleroma.Config.get([:mrf_emoji, :federated_timeline_removal_shortcode], [])
   end
 
-  @impl Pleroma.Web.ActivityPub.MRF.Policy
+  @impl true
   def history_awareness, do: :manual
 
-  @impl Pleroma.Web.ActivityPub.MRF.Policy
+  @impl true
-  def filter(%{"type" => type, "object" => %{"type" => objtype} = object} = message)
+  def filter(%{"type" => type, "object" => %{"type" => objtype} = object} = activity)
       when type in ["Create", "Update"] and objtype in Pleroma.Constants.status_object_types() do
     with {:ok, object} <-
            Updater.do_with_history(object, fn object ->
@@ -42,13 +42,13 @@ defmodule Pleroma.Web.ActivityPub.MRF.EmojiPolicy do
            Updater.do_with_history(object, fn object ->
              {:ok, process_remove(object, :shortcode, config_remove_shortcode())}
            end),
-         activity <- Map.put(message, "object", object),
+         activity <- Map.put(activity, "object", object),
          activity <- maybe_delist(activity) do
       {:ok, activity}
     end
   end
 
-  @impl Pleroma.Web.ActivityPub.MRF.Policy
+  @impl true
   def filter(%{"type" => type} = object) when type in Pleroma.Constants.actor_types() do
     with object <- process_remove(object, :url, config_remove_url()),
          object <- process_remove(object, :shortcode, config_remove_shortcode()) do
@@ -56,7 +56,7 @@ defmodule Pleroma.Web.ActivityPub.MRF.EmojiPolicy do
     end
   end
 
-  @impl Pleroma.Web.ActivityPub.MRF.Policy
+  @impl true
   def filter(%{"type" => "EmojiReact"} = object) do
     with {:ok, _} <-
            matched_emoji_checker(config_remove_url(), config_remove_shortcode()).(object) do
@@ -67,9 +67,9 @@ defmodule Pleroma.Web.ActivityPub.MRF.EmojiPolicy do
     end
   end
 
-  @impl Pleroma.Web.ActivityPub.MRF.Policy
+  @impl true
-  def filter(message) do
+  def filter(activity) do
-    {:ok, message}
+    {:ok, activity}
   end
 
   defp match_string?(string, pattern) when is_binary(pattern) do
@@ -214,7 +214,7 @@ defmodule Pleroma.Web.ActivityPub.MRF.EmojiPolicy do
     )
   end
 
-  @impl Pleroma.Web.ActivityPub.MRF.Policy
+  @impl true
   def describe do
     mrf_emoji =
       Pleroma.Config.get(:mrf_emoji, [])
@@ -226,7 +226,7 @@ defmodule Pleroma.Web.ActivityPub.MRF.EmojiPolicy do
     {:ok, %{mrf_emoji: mrf_emoji}}
   end
 
-  @impl Pleroma.Web.ActivityPub.MRF.Policy
+  @impl true
   def config_description do
     %{
       key: :mrf_emoji,
@@ -239,7 +239,7 @@ defmodule Pleroma.Web.ActivityPub.MRF.EmojiPolicy do
           key: :remove_url,
           type: {:list, :string},
           description: """
-            A list of patterns which result in emoji whose URL matches being removed from the message. This will apply to statuses, emoji reactions, and user profiles.
+            A list of patterns which result in emoji whose URL matches being removed from the activity. This will apply to statuses, emoji reactions, and user profiles.
 
             Each pattern can be a string or [Regex](https://hexdocs.pm/elixir/Regex.html) in the format of `~r/PATTERN/`.
           """,
@@ -249,7 +249,7 @@ defmodule Pleroma.Web.ActivityPub.MRF.EmojiPolicy do
           key: :remove_shortcode,
           type: {:list, :string},
           description: """
-            A list of patterns which result in emoji whose shortcode matches being removed from the message. This will apply to statuses, emoji reactions, and user profiles.
+            A list of patterns which result in emoji whose shortcode matches being removed from the activity. This will apply to statuses, emoji reactions, and user profiles.
 
             Each pattern can be a string or [Regex](https://hexdocs.pm/elixir/Regex.html) in the format of `~r/PATTERN/`.
           """,
@@ -259,7 +259,7 @@ defmodule Pleroma.Web.ActivityPub.MRF.EmojiPolicy do
           key: :federated_timeline_removal_url,
           type: {:list, :string},
           description: """
-            A list of patterns which result in message with emojis whose URLs match being removed from federated timelines (a.k.a unlisted). This will apply only to statuses.
+            A list of patterns which result in activity with emojis whose URLs match being removed from federated timelines (a.k.a unlisted). This will apply only to statuses.
 
             Each pattern can be a string or [Regex](https://hexdocs.pm/elixir/Regex.html) in the format of `~r/PATTERN/`.
           """,
@@ -269,7 +269,7 @@ defmodule Pleroma.Web.ActivityPub.MRF.EmojiPolicy do
           key: :federated_timeline_removal_shortcode,
           type: {:list, :string},
           description: """
-            A list of patterns which result in message with emojis whose shortcodes match being removed from federated timelines (a.k.a unlisted). This will apply only to statuses.
+            A list of patterns which result in activities with emojis whose shortcodes match being removed from federated timelines (a.k.a unlisted). This will apply only to statuses.
 
             Each pattern can be a string or [Regex](https://hexdocs.pm/elixir/Regex.html) in the format of `~r/PATTERN/`.
           """,

lib/pleroma/web/activity_pub/mrf/ensure_re_prepended.ex

@@ -29,19 +29,19 @@ defmodule Pleroma.Web.ActivityPub.MRF.EnsureRePrepended do
 
   def filter_by_summary(_in_reply_to, child), do: child
 
-  def filter(%{"type" => type, "object" => child_object} = object)
+  def filter(%{"type" => type, "object" => object} = activity)
-      when type in ["Create", "Update"] and is_map(child_object) do
+      when type in ["Create", "Update"] and is_map(object) do
     child =
-      child_object["inReplyTo"]
+      object["inReplyTo"]
       |> Object.normalize(fetch: false)
-      |> filter_by_summary(child_object)
+      |> filter_by_summary(object)
 
-    object = Map.put(object, "object", child)
+    activity = Map.put(activity, "object", child)
 
-    {:ok, object}
+    {:ok, activity}
   end
 
-  def filter(object), do: {:ok, object}
+  def filter(activity), do: {:ok, activity}
 
   def describe, do: {:ok, %{}}
 end

lib/pleroma/web/activity_pub/mrf/follow_bot_policy.ex

@@ -11,12 +11,12 @@ defmodule Pleroma.Web.ActivityPub.MRF.FollowBotPolicy do
   require Logger
 
   @impl true
-  def filter(message) do
+  def filter(activity) do
     with follower_nickname <- Config.get([:mrf_follow_bot, :follower_nickname]),
          %User{actor_type: "Service"} = follower <-
            User.get_cached_by_nickname(follower_nickname),
-         %{"type" => "Create", "object" => %{"type" => "Note"}} <- message do
+         %{"type" => "Create", "object" => %{"type" => "Note"}} <- activity do
-      try_follow(follower, message)
+      try_follow(follower, activity)
     else
       nil ->
         Logger.warning(
@@ -24,17 +24,17 @@ defmodule Pleroma.Web.ActivityPub.MRF.FollowBotPolicy do
             account does not exist, or the account is not correctly configured as a bot."
         )
 
-        {:ok, message}
+        {:ok, activity}
 
       _ ->
-        {:ok, message}
+        {:ok, activity}
     end
   end
 
-  defp try_follow(follower, message) do
+  defp try_follow(follower, activity) do
-    to = Map.get(message, "to", [])
+    to = Map.get(activity, "to", [])
-    cc = Map.get(message, "cc", [])
+    cc = Map.get(activity, "cc", [])
-    actor = [message["actor"]]
+    actor = [activity["actor"]]
 
     Enum.concat([to, cc, actor])
     |> List.flatten()
@@ -53,7 +53,7 @@ defmodule Pleroma.Web.ActivityPub.MRF.FollowBotPolicy do
       end
     end)
 
-    {:ok, message}
+    {:ok, activity}
   end
 
   @impl true

lib/pleroma/web/activity_pub/mrf/force_bot_unlisted_policy.ex

@@ -22,7 +22,7 @@ defmodule Pleroma.Web.ActivityPub.MRF.ForceBotUnlistedPolicy do
           "cc" => cc,
           "actor" => actor,
           "object" => object
-        } = message
+        } = activity
       ) do
     user = User.get_cached_by_ap_id(actor)
     isbot = check_if_bot(user)
@@ -36,20 +36,20 @@ defmodule Pleroma.Web.ActivityPub.MRF.ForceBotUnlistedPolicy do
         |> Map.put("to", to)
         |> Map.put("cc", cc)
 
-      message =
+      activity =
-        message
+        activity
         |> Map.put("to", to)
         |> Map.put("cc", cc)
         |> Map.put("object", object)
 
-      {:ok, message}
+      {:ok, activity}
     else
-      {:ok, message}
+      {:ok, activity}
     end
   end
 
   @impl true
-  def filter(message), do: {:ok, message}
+  def filter(activity), do: {:ok, activity}
 
   @impl true
   def describe, do: {:ok, %{}}

lib/pleroma/web/activity_pub/mrf/force_mention.ex

@@ -52,7 +52,7 @@ defmodule Pleroma.Web.ActivityPub.MRF.ForceMention do
   end
 
   @impl true
-  def filter(object), do: {:ok, object}
+  def filter(activity), do: {:ok, activity}
 
   @impl true
   def describe, do: {:ok, %{}}

lib/pleroma/web/activity_pub/mrf/force_mentions_in_content.ex

@@ -79,18 +79,18 @@ defmodule Pleroma.Web.ActivityPub.MRF.ForceMentionsInContent do
         %{
           "type" => type,
           "object" => %{"type" => "Note", "to" => to, "inReplyTo" => in_reply_to}
-        } = object
+        } = activity
       )
       when type in ["Create", "Update"] and is_list(to) and is_binary(in_reply_to) do
     # image-only posts from pleroma apparently reach this MRF without the content field
-    content = object["object"]["content"] || ""
+    content = activity["object"]["content"] || ""
 
     # Get the replied-to user for sorting
-    replied_to_user = get_replied_to_user(object["object"])
+    replied_to_user = get_replied_to_user(activity["object"])
 
     mention_users =
       to
-      |> clean_recipients(object)
+      |> clean_recipients(activity)
       |> Enum.map(&User.get_cached_by_ap_id/1)
       |> Enum.reject(&is_nil/1)
       |> sort_replied_user(replied_to_user)
@@ -126,11 +126,11 @@ defmodule Pleroma.Web.ActivityPub.MRF.ForceMentionsInContent do
           content
       end
 
-    {:ok, put_in(object["object"]["content"], content)}
+    {:ok, put_in(activity["object"]["content"], content)}
   end
 
   @impl true
-  def filter(object), do: {:ok, object}
+  def filter(activity), do: {:ok, activity}
 
   @impl true
   def describe, do: {:ok, %{}}

lib/pleroma/web/activity_pub/mrf/hashtag_policy.ex

@@ -9,7 +9,7 @@ defmodule Pleroma.Web.ActivityPub.MRF.HashtagPolicy do
   alias Pleroma.Object
 
   @moduledoc """
-  Reject, TWKN-remove or Set-Sensitive messages with specific hashtags (without the leading #)
+  Reject, TWKN-remove or Set-Sensitive activities with specific hashtags (without the leading #)
 
   Note: This MRF Policy is always enabled, if you want to disable it you have to set empty lists.
   """
@@ -19,40 +19,40 @@ defmodule Pleroma.Web.ActivityPub.MRF.HashtagPolicy do
   @impl true
   def history_awareness, do: :manual
 
-  defp check_reject(message, hashtags) do
+  defp check_reject(activity, hashtags) do
     if Enum.any?(Config.get([:mrf_hashtag, :reject]), fn match -> match in hashtags end) do
       {:reject, "[HashtagPolicy] Matches with rejected keyword"}
     else
-      {:ok, message}
+      {:ok, activity}
     end
   end
 
-  defp check_ftl_removal(%{"to" => to} = message, hashtags) do
+  defp check_ftl_removal(%{"to" => to} = activity, hashtags) do
     if Pleroma.Constants.as_public() in to and
          Enum.any?(Config.get([:mrf_hashtag, :federated_timeline_removal]), fn match ->
            match in hashtags
          end) do
       to = List.delete(to, Pleroma.Constants.as_public())
-      cc = [Pleroma.Constants.as_public() | message["cc"] || []]
+      cc = [Pleroma.Constants.as_public() | activity["cc"] || []]
 
-      message =
+      activity =
-        message
+        activity
         |> Map.put("to", to)
         |> Map.put("cc", cc)
         |> Kernel.put_in(["object", "to"], to)
         |> Kernel.put_in(["object", "cc"], cc)
 
-      {:ok, message}
+      {:ok, activity}
     else
-      {:ok, message}
+      {:ok, activity}
     end
   end
 
-  defp check_ftl_removal(message, _hashtags), do: {:ok, message}
+  defp check_ftl_removal(activity, _hashtags), do: {:ok, activity}
 
-  defp check_sensitive(message) do
+  defp check_sensitive(activity) do
     {:ok, new_object} =
-      Object.Updater.do_with_history(message["object"], fn object ->
+      Object.Updater.do_with_history(activity["object"], fn object ->
         hashtags = Object.hashtags(%Object{data: object})
 
         if Enum.any?(Config.get([:mrf_hashtag, :sensitive]), fn match -> match in hashtags end) do
@@ -62,11 +62,12 @@ defmodule Pleroma.Web.ActivityPub.MRF.HashtagPolicy do
         end
       end)
 
-    {:ok, Map.put(message, "object", new_object)}
+    {:ok, Map.put(activity, "object", new_object)}
   end
 
   @impl true
-  def filter(%{"type" => type, "object" => object} = message) when type in ["Create", "Update"] do
+  def filter(%{"type" => type, "object" => object} = activity)
+      when type in ["Create", "Update"] do
     history_items =
       with %{"formerRepresentations" => %{"orderedItems" => items}} <- object do
         items
@@ -82,23 +83,23 @@ defmodule Pleroma.Web.ActivityPub.MRF.HashtagPolicy do
     hashtags = Object.hashtags(%Object{data: object}) ++ historical_hashtags
 
     if hashtags != [] do
-      with {:ok, message} <- check_reject(message, hashtags),
+      with {:ok, activity} <- check_reject(activity, hashtags),
-           {:ok, message} <-
+           {:ok, activity} <-
              (if type == "Create" do
-                check_ftl_removal(message, hashtags)
+                check_ftl_removal(activity, hashtags)
               else
-                {:ok, message}
+                {:ok, activity}
               end),
-           {:ok, message} <- check_sensitive(message) do
+           {:ok, activity} <- check_sensitive(activity) do
-        {:ok, message}
+        {:ok, activity}
       end
     else
-      {:ok, message}
+      {:ok, activity}
     end
   end
 
   @impl true
-  def filter(message), do: {:ok, message}
+  def filter(activity), do: {:ok, activity}
 
   @impl true
   def describe do
@@ -120,21 +121,21 @@ defmodule Pleroma.Web.ActivityPub.MRF.HashtagPolicy do
         %{
           key: :reject,
           type: {:list, :string},
-          description: "A list of hashtags which result in message being rejected.",
+          description: "A list of hashtags which result in the activity being rejected.",
           suggestions: ["foo"]
         },
         %{
           key: :federated_timeline_removal,
           type: {:list, :string},
           description:
-            "A list of hashtags which result in message being removed from federated timelines (a.k.a unlisted).",
+            "A list of hashtags which result in the activity being removed from federated timelines (a.k.a unlisted).",
           suggestions: ["foo"]
         },
         %{
           key: :sensitive,
           type: {:list, :string},
           description:
-            "A list of hashtags which result in message being set as sensitive (a.k.a NSFW/R-18)",
+            "A list of hashtags which result in the activity being set as sensitive (a.k.a NSFW/R-18)",
           suggestions: ["nsfw", "r18"]
         }
       ]

lib/pleroma/web/activity_pub/mrf/hellthread_policy.ex

@@ -7,54 +7,54 @@ defmodule Pleroma.Web.ActivityPub.MRF.HellthreadPolicy do
 
   require Pleroma.Constants
 
-  @moduledoc "Block messages with too much mentions (configurable)"
+  @moduledoc "Block activities with too much mentions (configurable)"
 
   @behaviour Pleroma.Web.ActivityPub.MRF.Policy
 
-  defp delist_message(message, threshold) when threshold > 0 do
+  defp delist_activity(activity, threshold) when threshold > 0 do
-    follower_collection = User.get_cached_by_ap_id(message["actor"]).follower_address
+    follower_collection = User.get_cached_by_ap_id(activity["actor"]).follower_address
-    to = message["to"] || []
+    to = activity["to"] || []
-    cc = message["cc"] || []
+    cc = activity["cc"] || []
 
     follower_collection? = Enum.member?(to ++ cc, follower_collection)
 
-    message =
+    activity =
-      case get_recipient_count(message) do
+      case get_recipient_count(activity) do
         {:public, recipients}
         when follower_collection? and recipients > threshold ->
-          message
+          activity
           |> Map.put("to", [follower_collection])
           |> Map.put("cc", [Pleroma.Constants.as_public()])
 
         {:public, recipients} when recipients > threshold ->
-          message
+          activity
           |> Map.put("to", [])
           |> Map.put("cc", [Pleroma.Constants.as_public()])
 
         _ ->
-          message
+          activity
       end
 
-    {:ok, message}
+    {:ok, activity}
   end
 
-  defp delist_message(message, _threshold), do: {:ok, message}
+  defp delist_activity(activity, _threshold), do: {:ok, activity}
 
-  defp reject_message(message, threshold) when threshold > 0 do
+  defp reject_activity(activity, threshold) when threshold > 0 do
-    with {_, recipients} <- get_recipient_count(message) do
+    with {_, recipients} <- get_recipient_count(activity) do
       if recipients > threshold do
         {:reject, "[HellthreadPolicy] #{recipients} recipients is over the limit of #{threshold}"}
       else
-        {:ok, message}
+        {:ok, activity}
       end
     end
   end
 
-  defp reject_message(message, _threshold), do: {:ok, message}
+  defp reject_activity(activity, _threshold), do: {:ok, activity}
 
-  defp get_recipient_count(message) do
+  defp get_recipient_count(activity) do
-    recipients = (message["to"] || []) ++ (message["cc"] || [])
+    recipients = (activity["to"] || []) ++ (activity["cc"] || [])
-    follower_collection = User.get_cached_by_ap_id(message["actor"]).follower_address
+    follower_collection = User.get_cached_by_ap_id(activity["actor"]).follower_address
 
     if Enum.member?(recipients, Pleroma.Constants.as_public()) do
       recipients =
@@ -73,7 +73,7 @@ defmodule Pleroma.Web.ActivityPub.MRF.HellthreadPolicy do
   end
 
   @impl true
-  def filter(%{"type" => "Create", "object" => %{"type" => object_type}} = message)
+  def filter(%{"type" => "Create", "object" => %{"type" => object_type}} = activity)
       when object_type in ~w{Note Article} do
     reject_threshold =
       Pleroma.Config.get(
@@ -83,16 +83,16 @@ defmodule Pleroma.Web.ActivityPub.MRF.HellthreadPolicy do
 
     delist_threshold = Pleroma.Config.get([:mrf_hellthread, :delist_threshold])
 
-    with {:ok, message} <- reject_message(message, reject_threshold),
+    with {:ok, activity} <- reject_activity(activity, reject_threshold),
-         {:ok, message} <- delist_message(message, delist_threshold) do
+         {:ok, activity} <- delist_activity(activity, delist_threshold) do
-      {:ok, message}
+      {:ok, activity}
     else
       e -> e
     end
   end
 
   @impl true
-  def filter(message), do: {:ok, message}
+  def filter(activity), do: {:ok, activity}
 
   @impl true
   def describe,
@@ -104,13 +104,13 @@ defmodule Pleroma.Web.ActivityPub.MRF.HellthreadPolicy do
       key: :mrf_hellthread,
       related_policy: "Pleroma.Web.ActivityPub.MRF.HellthreadPolicy",
       label: "MRF Hellthread",
-      description: "Block messages with excessive user mentions",
+      description: "Block activities with excessive user mentions",
       children: [
         %{
           key: :delist_threshold,
           type: :integer,
           description:
-            "Number of mentioned users after which the message gets removed from timelines and" <>
+            "Number of mentioned users after which the activity gets removed from timelines and" <>
               "disables notifications. Set to 0 to disable.",
           suggestions: [10]
         },
@@ -118,7 +118,7 @@ defmodule Pleroma.Web.ActivityPub.MRF.HellthreadPolicy do
           key: :reject_threshold,
           type: :integer,
           description:
-            "Number of mentioned users after which the messaged gets rejected. Set to 0 to disable.",
+            "Number of mentioned users after which the activity gets rejected. Set to 0 to disable.",
           suggestions: [20]
         }
       ]

lib/pleroma/web/activity_pub/mrf/inline_quote_policy.ex

@@ -48,12 +48,12 @@ defmodule Pleroma.Web.ActivityPub.MRF.InlineQuotePolicy do
   end
 
   @impl true
-  def filter(object), do: {:ok, object}
+  def filter(activity), do: {:ok, activity}
 
   @impl true
   def describe, do: {:ok, %{}}
 
-  @impl Pleroma.Web.ActivityPub.MRF.Policy
+  @impl true
   def history_awareness, do: :auto
 
   @impl true

lib/pleroma/web/activity_pub/mrf/keyword_policy.ex

@@ -7,7 +7,7 @@ defmodule Pleroma.Web.ActivityPub.MRF.KeywordPolicy do
 
   alias Pleroma.Web.ActivityPub.MRF.Utils
 
-  @moduledoc "Reject or Word-Replace messages with a keyword or regex"
+  @moduledoc "Reject or Word-Replace activities with a keyword or regex"
 
   @behaviour Pleroma.Web.ActivityPub.MRF.Policy
 
@@ -25,7 +25,7 @@ defmodule Pleroma.Web.ActivityPub.MRF.KeywordPolicy do
     |> Enum.join("\n")
   end
 
-  defp check_reject(%{"object" => %{} = object} = message) do
+  defp check_reject(%{"object" => %{} = object} = activity) do
     with {:ok, _new_object} <-
            Pleroma.Object.Updater.do_with_history(object, fn object ->
              payload = object_payload(object)
@@ -35,16 +35,16 @@ defmodule Pleroma.Web.ActivityPub.MRF.KeywordPolicy do
                 end) do
                {:reject, "[KeywordPolicy] Matches with rejected keyword"}
              else
-               {:ok, message}
+               {:ok, activity}
              end
            end) do
-      {:ok, message}
+      {:ok, activity}
     else
       e -> e
     end
   end
 
-  defp check_ftl_removal(%{"type" => "Create", "to" => to, "object" => %{} = object} = message) do
+  defp check_ftl_removal(%{"type" => "Create", "to" => to, "object" => %{} = object} = activity) do
     check_keyword = fn object ->
       payload = object_payload(object)
 
@@ -67,24 +67,24 @@ defmodule Pleroma.Web.ActivityPub.MRF.KeywordPolicy do
 
     if Pleroma.Constants.as_public() in to and should_delist?.(object) do
       to = List.delete(to, Pleroma.Constants.as_public())
-      cc = [Pleroma.Constants.as_public() | message["cc"] || []]
+      cc = [Pleroma.Constants.as_public() | activity["cc"] || []]
 
-      message =
+      activity =
-        message
+        activity
         |> Map.put("to", to)
         |> Map.put("cc", cc)
 
-      {:ok, message}
+      {:ok, activity}
     else
-      {:ok, message}
+      {:ok, activity}
     end
   end
 
-  defp check_ftl_removal(message) do
+  defp check_ftl_removal(activity) do
-    {:ok, message}
+    {:ok, activity}
   end
 
-  defp check_replace(%{"object" => %{} = object} = message) do
+  defp check_replace(%{"object" => %{} = object} = activity) do
     replace_kw = fn object ->
       ["content", "name", "summary"]
       |> Enum.filter(fn field -> Map.has_key?(object, field) && object[field] end)
@@ -103,18 +103,18 @@ defmodule Pleroma.Web.ActivityPub.MRF.KeywordPolicy do
 
     {:ok, object} = Pleroma.Object.Updater.do_with_history(object, replace_kw)
 
-    message = Map.put(message, "object", object)
+    activity = Map.put(activity, "object", object)
 
-    {:ok, message}
+    {:ok, activity}
   end
 
   @impl true
-  def filter(%{"type" => type, "object" => %{"content" => _content}} = message)
+  def filter(%{"type" => type, "object" => %{"content" => _content}} = activity)
       when type in ["Create", "Update"] do
-    with {:ok, message} <- check_reject(message),
+    with {:ok, activity} <- check_reject(activity),
-         {:ok, message} <- check_ftl_removal(message),
+         {:ok, activity} <- check_ftl_removal(activity),
-         {:ok, message} <- check_replace(message) do
+         {:ok, activity} <- check_replace(activity) do
-      {:ok, message}
+      {:ok, activity}
     else
       {:reject, nil} -> {:reject, "[KeywordPolicy] "}
       {:reject, _} = e -> e
@@ -123,7 +123,7 @@ defmodule Pleroma.Web.ActivityPub.MRF.KeywordPolicy do
   end
 
   @impl true
-  def filter(message), do: {:ok, message}
+  def filter(activity), do: {:ok, activity}
 
   @impl true
   def describe do
@@ -154,13 +154,13 @@ defmodule Pleroma.Web.ActivityPub.MRF.KeywordPolicy do
       related_policy: "Pleroma.Web.ActivityPub.MRF.KeywordPolicy",
       label: "MRF Keyword",
       description:
-        "Reject or Word-Replace messages matching a keyword or [Regex](https://hexdocs.pm/elixir/Regex.html).",
+        "Reject or Word-Replace activities matching a keyword or [Regex](https://hexdocs.pm/elixir/Regex.html).",
       children: [
         %{
           key: :reject,
           type: {:list, :string},
           description: """
-            A list of patterns which result in message being rejected.
+            A list of patterns which result in the activity being rejected.
 
             Each pattern can be a string or [Regex](https://hexdocs.pm/elixir/Regex.html) in the format of `~r/PATTERN/`.
           """,
@@ -170,7 +170,7 @@ defmodule Pleroma.Web.ActivityPub.MRF.KeywordPolicy do
           key: :federated_timeline_removal,
           type: {:list, :string},
           description: """
-            A list of patterns which result in message being removed from federated timelines (a.k.a unlisted).
+            A list of patterns which result in the activity being removed from federated timelines (a.k.a unlisted).
 
             Each pattern can be a string or [Regex](https://hexdocs.pm/elixir/Regex.html) in the format of `~r/PATTERN/`.
           """,

lib/pleroma/web/activity_pub/mrf/media_proxy_warming_policy.ex

@@ -31,7 +31,7 @@ defmodule Pleroma.Web.ActivityPub.MRF.MediaProxyWarmingPolicy do
     HTTP.get(url, [], http_client_opts)
   end
 
-  defp preload(%{"object" => %{"attachment" => attachments}} = _message) do
+  defp preload(%{"object" => %{"attachment" => attachments}} = _activity) do
     Enum.each(attachments, fn
       %{"url" => url} when is_list(url) ->
         url
@@ -49,15 +49,15 @@ defmodule Pleroma.Web.ActivityPub.MRF.MediaProxyWarmingPolicy do
   end
 
   @impl true
-  def filter(%{"type" => type, "object" => %{"attachment" => attachments} = _object} = message)
+  def filter(%{"type" => type, "object" => %{"attachment" => attachments} = _object} = activity)
       when type in ["Create", "Update"] and is_list(attachments) and length(attachments) > 0 do
-    preload(message)
+    preload(activity)
 
-    {:ok, message}
+    {:ok, activity}
   end
 
   @impl true
-  def filter(message), do: {:ok, message}
+  def filter(activity), do: {:ok, activity}
 
   @impl true
   def describe, do: {:ok, %{}}

lib/pleroma/web/activity_pub/mrf/mention_policy.ex

@@ -3,25 +3,25 @@
 # SPDX-License-Identifier: AGPL-3.0-only
 
 defmodule Pleroma.Web.ActivityPub.MRF.MentionPolicy do
-  @moduledoc "Block messages which mention a user"
+  @moduledoc "Block activities which mention a user"
 
   @behaviour Pleroma.Web.ActivityPub.MRF.Policy
 
   @impl true
-  def filter(%{"type" => "Create"} = message) do
+  def filter(%{"type" => "Create"} = activity) do
     reject_actors = Pleroma.Config.get([:mrf_mention, :actors], [])
-    recipients = (message["to"] || []) ++ (message["cc"] || [])
+    recipients = (activity["to"] || []) ++ (activity["cc"] || [])
 
     if rejected_mention =
          Enum.find(recipients, fn recipient -> Enum.member?(reject_actors, recipient) end) do
       {:reject, "[MentionPolicy] Rejected for mention of #{rejected_mention}"}
     else
-      {:ok, message}
+      {:ok, activity}
     end
   end
 
   @impl true
-  def filter(message), do: {:ok, message}
+  def filter(activity), do: {:ok, activity}
 
   @impl true
   def describe, do: {:ok, %{}}
@@ -32,7 +32,7 @@ defmodule Pleroma.Web.ActivityPub.MRF.MentionPolicy do
       key: :mrf_mention,
       related_policy: "Pleroma.Web.ActivityPub.MRF.MentionPolicy",
       label: "MRF Mention",
-      description: "Block messages which mention a specific user",
+      description: "Block activities which mention a specific user",
       children: [
         %{
           key: :actors,

lib/pleroma/web/activity_pub/mrf/no_empty_policy.ex

@@ -9,20 +9,20 @@ defmodule Pleroma.Web.ActivityPub.MRF.NoEmptyPolicy do
   alias Pleroma.Web.Endpoint
 
   @impl true
-  def filter(%{"actor" => actor} = object) do
+  def filter(%{"actor" => actor} = activity) do
     with true <- local?(actor),
-         true <- eligible_type?(object),
+         true <- eligible_type?(activity),
-         true <- note?(object),
+         true <- note?(activity),
-         false <- has_attachment?(object),
+         false <- has_attachment?(activity),
-         true <- only_mentions?(object) do
+         true <- only_mentions?(activity) do
       {:reject, "[NoEmptyPolicy]"}
     else
       _ ->
-        {:ok, object}
+        {:ok, activity}
     end
   end
 
-  def filter(object), do: {:ok, object}
+  def filter(activity), do: {:ok, activity}
 
   defp local?(actor) do
     if actor |> String.starts_with?("#{Endpoint.url()}") do

lib/pleroma/web/activity_pub/mrf/no_op_policy.ex

@@ -7,8 +7,8 @@ defmodule Pleroma.Web.ActivityPub.MRF.NoOpPolicy do
   @behaviour Pleroma.Web.ActivityPub.MRF.Policy
 
   @impl true
-  def filter(object) do
+  def filter(activity) do
-    {:ok, object}
+    {:ok, activity}
   end
 
   @impl true

lib/pleroma/web/activity_pub/mrf/no_placeholder_text_policy.ex

@@ -13,15 +13,15 @@ defmodule Pleroma.Web.ActivityPub.MRF.NoPlaceholderTextPolicy do
   def filter(
         %{
           "type" => type,
-          "object" => %{"content" => content, "attachment" => _} = _child_object
+          "object" => %{"content" => content, "attachment" => _} = _object
-        } = object
+        } = activity
       )
       when type in ["Create", "Update"] and content in [".", "<p>.</p>"] do
-    {:ok, put_in(object, ["object", "content"], "")}
+    {:ok, put_in(activity, ["object", "content"], "")}
   end
 
   @impl true
-  def filter(object), do: {:ok, object}
+  def filter(activity), do: {:ok, activity}
 
   @impl true
   def describe, do: {:ok, %{}}

lib/pleroma/web/activity_pub/mrf/normalize_markup.ex

@@ -12,20 +12,20 @@ defmodule Pleroma.Web.ActivityPub.MRF.NormalizeMarkup do
   def history_awareness, do: :auto
 
   @impl true
-  def filter(%{"type" => type, "object" => child_object} = object)
+  def filter(%{"type" => type, "object" => object} = activity)
       when type in ["Create", "Update"] do
     scrub_policy = Pleroma.Config.get([:mrf_normalize_markup, :scrub_policy])
 
     content =
-      child_object["content"]
+      object["content"]
       |> HTML.filter_tags(scrub_policy)
 
-    object = put_in(object, ["object", "content"], content)
+    activity = put_in(activity, ["object", "content"], content)
 
-    {:ok, object}
+    {:ok, activity}
   end
 
-  def filter(object), do: {:ok, object}
+  def filter(activity), do: {:ok, activity}
 
   @impl true
   def describe, do: {:ok, %{}}

lib/pleroma/web/activity_pub/mrf/nsfw_api_policy.ex

@@ -122,52 +122,52 @@ defmodule Pleroma.Web.ActivityPub.MRF.NsfwApiPolicy do
     end
   end
 
-  def check_object_nsfw(%{"object" => %{} = child_object} = object) do
+  def check_object_nsfw(%{"object" => %{} = object} = activity) do
-    case check_object_nsfw(child_object) do
+    case check_object_nsfw(object) do
-      {:sfw, _} -> {:sfw, object}
+      {:sfw, _} -> {:sfw, activity}
-      {:nsfw, _} -> {:nsfw, object}
+      {:nsfw, _} -> {:nsfw, activity}
     end
   end
 
   def check_object_nsfw(object), do: {:sfw, object}
 
   @impl true
-  def filter(object) do
+  def filter(activity) do
-    with {:sfw, object} <- check_object_nsfw(object) do
+    with {:sfw, activity} <- check_object_nsfw(activity) do
-      {:ok, object}
+      {:ok, activity}
     else
-      {:nsfw, _data} -> handle_nsfw(object)
+      {:nsfw, _data} -> handle_nsfw(activity)
     end
   end
 
-  defp handle_nsfw(object) do
+  defp handle_nsfw(activity) do
     if Config.get([@policy, :reject]) do
-      {:reject, object}
+      {:reject, activity}
     else
       {:ok,
-       object
+       activity
        |> maybe_unlist()
        |> maybe_mark_sensitive()}
     end
   end
 
-  defp maybe_unlist(object) do
+  defp maybe_unlist(activity) do
     if Config.get([@policy, :unlist]) do
-      unlist(object)
+      unlist(activity)
     else
-      object
+      activity
     end
   end
 
-  defp maybe_mark_sensitive(object) do
+  defp maybe_mark_sensitive(activity) do
     if Config.get([@policy, :mark_sensitive]) do
-      mark_sensitive(object)
+      mark_sensitive(activity)
     else
-      object
+      activity
     end
   end
 
-  def unlist(%{"to" => to, "cc" => cc, "actor" => actor} = object) do
+  def unlist(%{"to" => to, "cc" => cc, "actor" => actor} = activity) do
     with %User{} = user <- User.get_cached_by_ap_id(actor) do
       to =
         [user.follower_address | to]
@@ -179,7 +179,7 @@ defmodule Pleroma.Web.ActivityPub.MRF.NsfwApiPolicy do
         |> List.delete(user.follower_address)
         |> Enum.uniq()
 
-      object
+      activity
       |> Map.put("to", to)
       |> Map.put("cc", cc)
     else
@@ -187,14 +187,14 @@ defmodule Pleroma.Web.ActivityPub.MRF.NsfwApiPolicy do
     end
   end
 
-  def mark_sensitive(%{"object" => child_object} = object) when is_map(child_object) do
+  def mark_sensitive(%{"object" => object} = activity) when is_map(object) do
-    Map.put(object, "object", mark_sensitive(child_object))
+    Map.put(activity, "object", mark_sensitive(object))
   end
 
-  def mark_sensitive(object) when is_map(object) do
+  def mark_sensitive(activity) when is_map(activity) do
-    tags = (object["tag"] || []) ++ ["nsfw"]
+    tags = (activity["tag"] || []) ++ ["nsfw"]
 
-    object
+    activity
     |> Map.put("tag", tags)
     |> Map.put("sensitive", true)
   end

lib/pleroma/web/activity_pub/mrf/object_age_policy.ex

@@ -11,12 +11,12 @@ defmodule Pleroma.Web.ActivityPub.MRF.ObjectAgePolicy do
   @moduledoc "Filter activities depending on their age"
   @behaviour Pleroma.Web.ActivityPub.MRF.Policy
 
-  defp check_date(%{"object" => %{"published" => published}} = message) do
+  defp check_date(%{"object" => %{"published" => published}} = activity) do
     with %DateTime{} = now <- DateTime.utc_now(),
          {:ok, %DateTime{} = then, _} <- DateTime.from_iso8601(published),
          max_ttl <- Config.get([:mrf_object_age, :threshold]),
          {:ttl, false} <- {:ttl, DateTime.diff(now, then) > max_ttl} do
-      {:ok, message}
+      {:ok, activity}
     else
       {:ttl, true} ->
         {:reject, nil}
@@ -26,73 +26,73 @@ defmodule Pleroma.Web.ActivityPub.MRF.ObjectAgePolicy do
     end
   end
 
-  defp check_reject(message, actions) do
+  defp check_reject(activity, actions) do
     if :reject in actions do
       {:reject, "[ObjectAgePolicy]"}
     else
-      {:ok, message}
+      {:ok, activity}
     end
   end
 
-  defp check_delist(message, actions) do
+  defp check_delist(activity, actions) do
     if :delist in actions do
-      with %User{} = user <- User.get_cached_by_ap_id(message["actor"]) do
+      with %User{} = user <- User.get_cached_by_ap_id(activity["actor"]) do
         to =
-          List.delete(message["to"] || [], Pleroma.Constants.as_public()) ++
+          List.delete(activity["to"] || [], Pleroma.Constants.as_public()) ++
             [user.follower_address]
 
         cc =
-          List.delete(message["cc"] || [], user.follower_address) ++
+          List.delete(activity["cc"] || [], user.follower_address) ++
             [Pleroma.Constants.as_public()]
 
-        message =
+        activity =
-          message
+          activity
           |> Map.put("to", to)
           |> Map.put("cc", cc)
           |> Kernel.put_in(["object", "to"], to)
           |> Kernel.put_in(["object", "cc"], cc)
 
-        {:ok, message}
+        {:ok, activity}
       else
         _e ->
           {:reject, "[ObjectAgePolicy] Unhandled error"}
       end
     else
-      {:ok, message}
+      {:ok, activity}
     end
   end
 
-  defp check_strip_followers(message, actions) do
+  defp check_strip_followers(activity, actions) do
     if :strip_followers in actions do
-      with %User{} = user <- User.get_cached_by_ap_id(message["actor"]) do
+      with %User{} = user <- User.get_cached_by_ap_id(activity["actor"]) do
-        to = List.delete(message["to"] || [], user.follower_address)
+        to = List.delete(activity["to"] || [], user.follower_address)
-        cc = List.delete(message["cc"] || [], user.follower_address)
+        cc = List.delete(activity["cc"] || [], user.follower_address)
 
-        message =
+        activity =
-          message
+          activity
           |> Map.put("to", to)
           |> Map.put("cc", cc)
           |> Kernel.put_in(["object", "to"], to)
           |> Kernel.put_in(["object", "cc"], cc)
 
-        {:ok, message}
+        {:ok, activity}
       else
         _e ->
           {:reject, "[ObjectAgePolicy] Unhandled error"}
       end
     else
-      {:ok, message}
+      {:ok, activity}
     end
   end
 
   @impl true
-  def filter(%{"type" => "Create", "object" => %{"published" => _}} = message) do
+  def filter(%{"type" => "Create", "object" => %{"published" => _}} = activity) do
     with actions <- Config.get([:mrf_object_age, :actions]),
-         {:reject, _} <- check_date(message),
+         {:reject, _} <- check_date(activity),
-         {:ok, message} <- check_reject(message, actions),
+         {:ok, activity} <- check_reject(activity, actions),
-         {:ok, message} <- check_delist(message, actions),
+         {:ok, activity} <- check_delist(activity, actions),
-         {:ok, message} <- check_strip_followers(message, actions) do
+         {:ok, activity} <- check_strip_followers(activity, actions) do
-      {:ok, message}
+      {:ok, activity}
     else
       # check_date() is allowed to short-circuit the pipeline
       e -> e
@@ -100,7 +100,7 @@ defmodule Pleroma.Web.ActivityPub.MRF.ObjectAgePolicy do
   end
 
   @impl true
-  def filter(message), do: {:ok, message}
+  def filter(activity), do: {:ok, activity}
 
   @impl true
   def describe do
@@ -131,8 +131,8 @@ defmodule Pleroma.Web.ActivityPub.MRF.ObjectAgePolicy do
           type: {:list, :atom},
           description:
             "A list of actions to apply to the post. `:delist` removes the post from public timelines; " <>
-              "`:strip_followers` removes followers from the ActivityPub recipient list ensuring they won't be delivered to home timelines, additionally for followers-only it degrades to a direct message; " <>
+              "`:strip_followers` removes followers from the ActivityPub recipient list ensuring they won't be delivered to home timelines, additionally for followers-only it degrades to a direct activity; " <>
-              "`:reject` rejects the message entirely",
+              "`:reject` rejects the activity entirely",
           suggestions: [:delist, :strip_followers, :reject]
         }
       ]

lib/pleroma/web/activity_pub/mrf/policy.ex

@@ -3,7 +3,7 @@
 # SPDX-License-Identifier: AGPL-3.0-only
 
 defmodule Pleroma.Web.ActivityPub.MRF.Policy do
-  @callback filter(map()) :: {:ok | :reject, map()}
+  @callback filter(Pleroma.Activity.t()) :: {:ok | :reject, Pleroma.Activity.t()}
   @callback describe() :: {:ok | :error, map()}
   @callback config_description() :: %{
               optional(:children) => [map()],

lib/pleroma/web/activity_pub/mrf/quiet_reply.ex

@@ -26,7 +26,7 @@ defmodule Pleroma.Web.ActivityPub.MRF.QuietReply do
             "type" => "Note",
             "inReplyTo" => in_reply_to
           }
-        } = object
+        } = activity
       ) do
     with true <- is_binary(in_reply_to),
          false <- match?([], cc),
@@ -39,21 +39,21 @@ defmodule Pleroma.Web.ActivityPub.MRF.QuietReply do
 
       updated_cc = [Pleroma.Constants.as_public()]
 
-      updated_object =
+      updated_activity =
-        object
+        activity
         |> Map.put("to", updated_to)
         |> Map.put("cc", updated_cc)
         |> put_in(["object", "to"], updated_to)
         |> put_in(["object", "cc"], updated_cc)
 
-      {:ok, updated_object}
+      {:ok, updated_activity}
     else
-      _ -> {:ok, object}
+      _ -> {:ok, activity}
     end
   end
 
   @impl true
-  def filter(object), do: {:ok, object}
+  def filter(activity), do: {:ok, activity}
 
   @impl true
   def describe, do: {:ok, %{}}

lib/pleroma/web/activity_pub/mrf/quote_to_link_tag_policy.ex

@@ -10,18 +10,18 @@ defmodule Pleroma.Web.ActivityPub.MRF.QuoteToLinkTagPolicy do
 
   require Pleroma.Constants
 
-  @impl Pleroma.Web.ActivityPub.MRF.Policy
+  @impl true
   def filter(%{"object" => %{"quoteUrl" => _} = object} = activity) do
     {:ok, Map.put(activity, "object", filter_object(object))}
   end
 
-  @impl Pleroma.Web.ActivityPub.MRF.Policy
+  @impl true
-  def filter(object), do: {:ok, object}
+  def filter(activity), do: {:ok, activity}
 
-  @impl Pleroma.Web.ActivityPub.MRF.Policy
+  @impl true
   def describe, do: {:ok, %{}}
 
-  @impl Pleroma.Web.ActivityPub.MRF.Policy
+  @impl true
   def history_awareness, do: :auto
 
   defp filter_object(%{"quoteUrl" => quote_url} = object) do

lib/pleroma/web/activity_pub/mrf/simple_policy.ex

@@ -13,20 +13,20 @@ defmodule Pleroma.Web.ActivityPub.MRF.SimplePolicy do
 
   require Pleroma.Constants
 
-  defp check_accept(%{host: actor_host} = _actor_info, object) do
+  defp check_accept(%{host: actor_host} = _actor_info, activity) do
     accepts =
       instance_list(:accept)
       |> MRF.subdomains_regex()
 
     cond do
-      accepts == [] -> {:ok, object}
+      accepts == [] -> {:ok, activity}
-      actor_host == Config.get([Pleroma.Web.Endpoint, :url, :host]) -> {:ok, object}
+      actor_host == Config.get([Pleroma.Web.Endpoint, :url, :host]) -> {:ok, activity}
-      MRF.subdomain_match?(accepts, actor_host) -> {:ok, object}
+      MRF.subdomain_match?(accepts, actor_host) -> {:ok, activity}
       true -> {:reject, "[SimplePolicy] host not in accept list"}
     end
   end
 
-  defp check_reject(%{host: actor_host} = _actor_info, object) do
+  defp check_reject(%{host: actor_host} = _actor_info, activity) do
     rejects =
       instance_list(:reject)
       |> MRF.subdomains_regex()
@@ -34,109 +34,109 @@ defmodule Pleroma.Web.ActivityPub.MRF.SimplePolicy do
     if MRF.subdomain_match?(rejects, actor_host) do
       {:reject, "[SimplePolicy] host in reject list"}
     else
-      {:ok, object}
+      {:ok, activity}
     end
   end
 
   defp check_media_removal(
          %{host: actor_host} = _actor_info,
-         %{"type" => type, "object" => %{"attachment" => child_attachment}} = object
+         %{"type" => type, "object" => %{"attachment" => object_attachment}} = activity
        )
-       when length(child_attachment) > 0 and type in ["Create", "Update"] do
+       when length(object_attachment) > 0 and type in ["Create", "Update"] do
     media_removal =
       instance_list(:media_removal)
       |> MRF.subdomains_regex()
 
-    object =
+    activity =
       if MRF.subdomain_match?(media_removal, actor_host) do
-        child_object = Map.delete(object["object"], "attachment")
+        object = Map.delete(activity["object"], "attachment")
-        Map.put(object, "object", child_object)
+        Map.put(activity, "object", object)
       else
-        object
+        activity
       end
 
-    {:ok, object}
+    {:ok, activity}
   end
 
-  defp check_media_removal(_actor_info, object), do: {:ok, object}
+  defp check_media_removal(_actor_info, activity), do: {:ok, activity}
 
   defp check_media_nsfw(
          %{host: actor_host} = _actor_info,
          %{
            "type" => type,
-           "object" => %{} = _child_object
+           "object" => %{} = _object
-         } = object
+         } = activity
        )
        when type in ["Create", "Update"] do
     media_nsfw =
       instance_list(:media_nsfw)
       |> MRF.subdomains_regex()
 
-    object =
+    activity =
       if MRF.subdomain_match?(media_nsfw, actor_host) do
-        Kernel.put_in(object, ["object", "sensitive"], true)
+        Kernel.put_in(activity, ["object", "sensitive"], true)
       else
-        object
+        activity
       end
 
-    {:ok, object}
+    {:ok, activity}
   end
 
-  defp check_media_nsfw(_actor_info, object), do: {:ok, object}
+  defp check_media_nsfw(_actor_info, activity), do: {:ok, activity}
 
-  defp check_ftl_removal(%{host: actor_host} = _actor_info, object) do
+  defp check_ftl_removal(%{host: actor_host} = _actor_info, activity) do
     timeline_removal =
       instance_list(:federated_timeline_removal)
       |> MRF.subdomains_regex()
 
-    object =
+    activity =
       with true <- MRF.subdomain_match?(timeline_removal, actor_host),
-           user <- User.get_cached_by_ap_id(object["actor"]),
+           user <- User.get_cached_by_ap_id(activity["actor"]),
-           true <- Pleroma.Constants.as_public() in object["to"] do
+           true <- Pleroma.Constants.as_public() in activity["to"] do
-        to = List.delete(object["to"], Pleroma.Constants.as_public()) ++ [user.follower_address]
+        to = List.delete(activity["to"], Pleroma.Constants.as_public()) ++ [user.follower_address]
 
-        cc = List.delete(object["cc"], user.follower_address) ++ [Pleroma.Constants.as_public()]
+        cc = List.delete(activity["cc"], user.follower_address) ++ [Pleroma.Constants.as_public()]
 
-        object
+        activity
         |> Map.put("to", to)
         |> Map.put("cc", cc)
       else
-        _ -> object
+        _ -> activity
       end
 
-    {:ok, object}
+    {:ok, activity}
   end
 
   defp intersection(list1, list2) do
     list1 -- list1 -- list2
   end
 
-  defp check_followers_only(%{host: actor_host} = _actor_info, object) do
+  defp check_followers_only(%{host: actor_host} = _actor_info, activity) do
     followers_only =
       instance_list(:followers_only)
       |> MRF.subdomains_regex()
 
-    object =
+    activity =
       with true <- MRF.subdomain_match?(followers_only, actor_host),
-           user <- User.get_cached_by_ap_id(object["actor"]) do
+           user <- User.get_cached_by_ap_id(activity["actor"]) do
         # Don't use Map.get/3 intentionally, these must not be nil
-        fixed_to = object["to"] || []
+        fixed_to = activity["to"] || []
-        fixed_cc = object["cc"] || []
+        fixed_cc = activity["cc"] || []
 
         to = FollowingRelationship.followers_ap_ids(user, fixed_to)
         cc = FollowingRelationship.followers_ap_ids(user, fixed_cc)
 
-        object
+        activity
         |> Map.put("to", intersection([user.follower_address | to], fixed_to))
         |> Map.put("cc", intersection([user.follower_address | cc], fixed_cc))
       else
-        _ -> object
+        _ -> activity
       end
 
-    {:ok, object}
+    {:ok, activity}
   end
 
-  defp check_report_removal(%{host: actor_host} = _actor_info, %{"type" => "Flag"} = object) do
+  defp check_report_removal(%{host: actor_host} = _actor_info, %{"type" => "Flag"} = activity) do
     report_removal =
       instance_list(:report_removal)
       |> MRF.subdomains_regex()
@@ -144,39 +144,39 @@ defmodule Pleroma.Web.ActivityPub.MRF.SimplePolicy do
     if MRF.subdomain_match?(report_removal, actor_host) do
       {:reject, "[SimplePolicy] host in report_removal list"}
     else
-      {:ok, object}
+      {:ok, activity}
     end
   end
 
-  defp check_report_removal(_actor_info, object), do: {:ok, object}
+  defp check_report_removal(_actor_info, activity), do: {:ok, activity}
 
-  defp check_avatar_removal(%{host: actor_host} = _actor_info, %{"icon" => _icon} = object) do
+  defp check_avatar_removal(%{host: actor_host} = _actor_info, %{"icon" => _icon} = activity) do
     avatar_removal =
       instance_list(:avatar_removal)
       |> MRF.subdomains_regex()
 
     if MRF.subdomain_match?(avatar_removal, actor_host) do
-      {:ok, Map.delete(object, "icon")}
+      {:ok, Map.delete(activity, "icon")}
     else
-      {:ok, object}
+      {:ok, activity}
     end
   end
 
-  defp check_avatar_removal(_actor_info, object), do: {:ok, object}
+  defp check_avatar_removal(_actor_info, activity), do: {:ok, activity}
 
-  defp check_banner_removal(%{host: actor_host} = _actor_info, %{"image" => _image} = object) do
+  defp check_banner_removal(%{host: actor_host} = _actor_info, %{"image" => _image} = activity) do
     banner_removal =
       instance_list(:banner_removal)
       |> MRF.subdomains_regex()
 
     if MRF.subdomain_match?(banner_removal, actor_host) do
-      {:ok, Map.delete(object, "image")}
+      {:ok, Map.delete(activity, "image")}
     else
-      {:ok, object}
+      {:ok, activity}
     end
   end
 
-  defp check_banner_removal(_actor_info, object), do: {:ok, object}
+  defp check_banner_removal(_actor_info, activity), do: {:ok, activity}
 
   defp check_object(%{"object" => object} = activity) do
     with {:ok, _object} <- filter(object) do
@@ -184,7 +184,7 @@ defmodule Pleroma.Web.ActivityPub.MRF.SimplePolicy do
     end
   end
 
-  defp check_object(object), do: {:ok, object}
+  defp check_object(activity), do: {:ok, activity}
 
   defp instance_list(config_key) do
     Config.get([:mrf_simple, config_key])
@@ -192,7 +192,7 @@ defmodule Pleroma.Web.ActivityPub.MRF.SimplePolicy do
   end
 
   @impl true
-  def filter(%{"type" => "Delete", "actor" => actor} = object) do
+  def filter(%{"type" => "Delete", "actor" => actor} = activity) do
     %{host: actor_host} = URI.parse(actor)
 
     reject_deletes =
@@ -202,54 +202,54 @@ defmodule Pleroma.Web.ActivityPub.MRF.SimplePolicy do
     if MRF.subdomain_match?(reject_deletes, actor_host) do
       {:reject, "[SimplePolicy] host in reject_deletes list"}
     else
-      {:ok, object}
+      {:ok, activity}
     end
   end
 
   @impl true
-  def filter(%{"actor" => actor} = object) do
+  def filter(%{"actor" => actor} = activity) do
     actor_info = URI.parse(actor)
 
-    with {:ok, object} <- check_accept(actor_info, object),
+    with {:ok, activity} <- check_accept(actor_info, activity),
-         {:ok, object} <- check_reject(actor_info, object),
+         {:ok, activity} <- check_reject(actor_info, activity),
-         {:ok, object} <- check_media_removal(actor_info, object),
+         {:ok, activity} <- check_media_removal(actor_info, activity),
-         {:ok, object} <- check_media_nsfw(actor_info, object),
+         {:ok, activity} <- check_media_nsfw(actor_info, activity),
-         {:ok, object} <- check_ftl_removal(actor_info, object),
+         {:ok, activity} <- check_ftl_removal(actor_info, activity),
-         {:ok, object} <- check_followers_only(actor_info, object),
+         {:ok, activity} <- check_followers_only(actor_info, activity),
-         {:ok, object} <- check_report_removal(actor_info, object),
+         {:ok, activity} <- check_report_removal(actor_info, activity),
-         {:ok, object} <- check_object(object) do
+         {:ok, activity} <- check_object(activity) do
-      {:ok, object}
+      {:ok, activity}
     else
       {:reject, _} = e -> e
     end
   end
 
-  def filter(%{"id" => actor, "type" => obj_type} = object)
+  def filter(%{"id" => actor, "type" => actor_type} = activity)
-      when obj_type in ["Application", "Group", "Organization", "Person", "Service"] do
+      when actor_type in ["Application", "Group", "Organization", "Person", "Service"] do
     actor_info = URI.parse(actor)
 
-    with {:ok, object} <- check_accept(actor_info, object),
+    with {:ok, activity} <- check_accept(actor_info, activity),
-         {:ok, object} <- check_reject(actor_info, object),
+         {:ok, activity} <- check_reject(actor_info, activity),
-         {:ok, object} <- check_avatar_removal(actor_info, object),
+         {:ok, activity} <- check_avatar_removal(actor_info, activity),
-         {:ok, object} <- check_banner_removal(actor_info, object) do
+         {:ok, activity} <- check_banner_removal(actor_info, activity) do
-      {:ok, object}
+      {:ok, activity}
     else
       {:reject, _} = e -> e
     end
   end
 
-  def filter(object) when is_binary(object) do
+  def filter(activity) when is_binary(activity) do
-    uri = URI.parse(object)
+    uri = URI.parse(activity)
 
-    with {:ok, object} <- check_accept(uri, object),
+    with {:ok, activity} <- check_accept(uri, activity),
-         {:ok, object} <- check_reject(uri, object) do
+         {:ok, activity} <- check_reject(uri, activity) do
-      {:ok, object}
+      {:ok, activity}
     else
       {:reject, _} = e -> e
     end
   end
 
-  def filter(object), do: {:ok, object}
+  def filter(activity), do: {:ok, activity}
 
   @impl true
   def describe do

lib/pleroma/web/activity_pub/mrf/steal_emoji_policy.ex

@@ -62,7 +62,7 @@ defmodule Pleroma.Web.ActivityPub.MRF.StealEmojiPolicy do
   end
 
   @impl true
-  def filter(%{"object" => %{"emoji" => foreign_emojis, "actor" => actor}} = message) do
+  def filter(%{"object" => %{"emoji" => foreign_emojis, "actor" => actor}} = activity) do
     host = URI.parse(actor).host
 
     if host != Pleroma.Web.Endpoint.host() and accept_host?(host) do
@@ -97,10 +97,10 @@ defmodule Pleroma.Web.ActivityPub.MRF.StealEmojiPolicy do
       end
     end
 
-    {:ok, message}
+    {:ok, activity}
   end
 
-  def filter(message), do: {:ok, message}
+  def filter(activity), do: {:ok, activity}
 
   @impl true
   @spec config_description :: %{

lib/pleroma/web/activity_pub/mrf/subchain_policy.ex

@@ -20,20 +20,20 @@ defmodule Pleroma.Web.ActivityPub.MRF.SubchainPolicy do
   end
 
   @impl true
-  def filter(%{"actor" => actor} = message) do
+  def filter(%{"actor" => actor} = activity) do
     with {:ok, match, subchain} <- lookup_subchain(actor) do
       Logger.debug(
         "[SubchainPolicy] Matched #{actor} against #{inspect(match)} with subchain #{inspect(subchain)}"
       )
 
-      MRF.filter(subchain, message)
+      MRF.filter(subchain, activity)
     else
-      _e -> {:ok, message}
+      _e -> {:ok, activity}
     end
   end
 
   @impl true
-  def filter(message), do: {:ok, message}
+  def filter(activity), do: {:ok, activity}
 
   @impl true
   def describe, do: {:ok, %{}}
@@ -45,7 +45,7 @@ defmodule Pleroma.Web.ActivityPub.MRF.SubchainPolicy do
       related_policy: "Pleroma.Web.ActivityPub.MRF.SubchainPolicy",
       label: "MRF Subchain",
       description:
-        "This policy processes messages through an alternate pipeline when a given message matches certain criteria." <>
+        "This policy processes activities through an alternate pipeline when a given activity matches certain criteria." <>
           " All criteria are configured as a map of regular expressions to lists of policy modules.",
       children: [
         %{

lib/pleroma/web/activity_pub/mrf/tag_policy.ex

@@ -28,25 +28,25 @@ defmodule Pleroma.Web.ActivityPub.MRF.TagPolicy do
          "mrf_tag:media-force-nsfw",
          %{
            "type" => type,
-           "object" => %{"attachment" => child_attachment}
+           "object" => %{"attachment" => object_attachment}
-         } = message
+         } = activity
        )
-       when length(child_attachment) > 0 and type in ["Create", "Update"] do
+       when length(object_attachment) > 0 and type in ["Create", "Update"] do
-    {:ok, Kernel.put_in(message, ["object", "sensitive"], true)}
+    {:ok, Kernel.put_in(activity, ["object", "sensitive"], true)}
   end
 
   defp process_tag(
          "mrf_tag:media-strip",
          %{
            "type" => type,
-           "object" => %{"attachment" => child_attachment} = object
+           "object" => %{"attachment" => object_attachment} = object
-         } = message
+         } = activity
        )
-       when length(child_attachment) > 0 and type in ["Create", "Update"] do
+       when length(object_attachment) > 0 and type in ["Create", "Update"] do
     object = Map.delete(object, "attachment")
-    message = Map.put(message, "object", object)
+    activity = Map.put(activity, "object", object)
 
-    {:ok, message}
+    {:ok, activity}
   end
 
   defp process_tag(
@@ -57,7 +57,7 @@ defmodule Pleroma.Web.ActivityPub.MRF.TagPolicy do
            "cc" => cc,
            "actor" => actor,
            "object" => object
-         } = message
+         } = activity
        ) do
     user = User.get_cached_by_ap_id(actor)
 
@@ -70,15 +70,15 @@ defmodule Pleroma.Web.ActivityPub.MRF.TagPolicy do
         |> Map.put("to", to)
         |> Map.put("cc", cc)
 
-      message =
+      activity =
-        message
+        activity
         |> Map.put("to", to)
         |> Map.put("cc", cc)
         |> Map.put("object", object)
 
-      {:ok, message}
+      {:ok, activity}
     else
-      {:ok, message}
+      {:ok, activity}
     end
   end
 
@@ -90,7 +90,7 @@ defmodule Pleroma.Web.ActivityPub.MRF.TagPolicy do
            "cc" => cc,
            "actor" => actor,
            "object" => object
-         } = message
+         } = activity
        ) do
     user = User.get_cached_by_ap_id(actor)
 
@@ -104,26 +104,26 @@ defmodule Pleroma.Web.ActivityPub.MRF.TagPolicy do
         |> Map.put("to", to)
         |> Map.put("cc", cc)
 
-      message =
+      activity =
-        message
+        activity
         |> Map.put("to", to)
         |> Map.put("cc", cc)
         |> Map.put("object", object)
 
-      {:ok, message}
+      {:ok, activity}
     else
-      {:ok, message}
+      {:ok, activity}
     end
   end
 
   defp process_tag(
          "mrf_tag:disable-remote-subscription",
-         %{"type" => "Follow", "actor" => actor} = message
+         %{"type" => "Follow", "actor" => actor} = activity
        ) do
     user = User.get_cached_by_ap_id(actor)
 
     if user.local == true do
-      {:ok, message}
+      {:ok, activity}
     else
       {:reject,
        "[TagPolicy] Follow from #{actor} tagged with mrf_tag:disable-remote-subscription"}
@@ -133,14 +133,14 @@ defmodule Pleroma.Web.ActivityPub.MRF.TagPolicy do
   defp process_tag("mrf_tag:disable-any-subscription", %{"type" => "Follow", "actor" => actor}),
     do: {:reject, "[TagPolicy] Follow from #{actor} tagged with mrf_tag:disable-any-subscription"}
 
-  defp process_tag(_, message), do: {:ok, message}
+  defp process_tag(_, activity), do: {:ok, activity}
 
-  def filter_message(actor, message) do
+  def filter_activity(actor, activity) do
     User.get_cached_by_ap_id(actor)
     |> get_tags()
-    |> Enum.reduce({:ok, message}, fn
+    |> Enum.reduce({:ok, activity}, fn
-      tag, {:ok, message} ->
+      tag, {:ok, activity} ->
-        process_tag(tag, message)
+        process_tag(tag, activity)
 
       _, error ->
         error
@@ -148,15 +148,15 @@ defmodule Pleroma.Web.ActivityPub.MRF.TagPolicy do
   end
 
   @impl true
-  def filter(%{"object" => target_actor, "type" => "Follow"} = message),
+  def filter(%{"object" => target_actor, "type" => "Follow"} = activity),
-    do: filter_message(target_actor, message)
+    do: filter_activity(target_actor, activity)
 
   @impl true
-  def filter(%{"actor" => actor, "type" => type} = message) when type in ["Create", "Update"],
+  def filter(%{"actor" => actor, "type" => type} = activity) when type in ["Create", "Update"],
-    do: filter_message(actor, message)
+    do: filter_activity(actor, activity)
 
   @impl true
-  def filter(message), do: {:ok, message}
+  def filter(activity), do: {:ok, activity}
 
   @impl true
   def describe, do: {:ok, %{}}

lib/pleroma/web/activity_pub/mrf/user_allow_list_policy.ex

@@ -8,18 +8,18 @@ defmodule Pleroma.Web.ActivityPub.MRF.UserAllowListPolicy do
   @moduledoc "Accept-list of users from specified instances"
   @behaviour Pleroma.Web.ActivityPub.MRF.Policy
 
-  defp filter_by_list(object, []), do: {:ok, object}
+  defp filter_by_list(activity, []), do: {:ok, activity}
 
-  defp filter_by_list(%{"actor" => actor} = object, allow_list) do
+  defp filter_by_list(%{"actor" => actor} = activity, allow_list) do
     if actor in allow_list do
-      {:ok, object}
+      {:ok, activity}
     else
       {:reject, "[UserAllowListPolicy] #{actor} not in the list"}
     end
   end
 
   @impl true
-  def filter(%{"actor" => actor} = object) do
+  def filter(%{"actor" => actor} = activity) do
     actor_info = URI.parse(actor)
 
     allow_list =
@@ -28,10 +28,10 @@ defmodule Pleroma.Web.ActivityPub.MRF.UserAllowListPolicy do
         []
       )
 
-    filter_by_list(object, allow_list)
+    filter_by_list(activity, allow_list)
   end
 
-  def filter(object), do: {:ok, object}
+  def filter(activity), do: {:ok, activity}
 
   @impl true
   def describe do

lib/pleroma/web/activity_pub/mrf/vocabulary_policy.ex

@@ -3,38 +3,38 @@
 # SPDX-License-Identifier: AGPL-3.0-only
 
 defmodule Pleroma.Web.ActivityPub.MRF.VocabularyPolicy do
-  @moduledoc "Filter messages which belong to certain activity vocabularies"
+  @moduledoc "Filter activities which belong to certain activity vocabularies"
 
   @behaviour Pleroma.Web.ActivityPub.MRF.Policy
 
   @impl true
-  def filter(%{"type" => "Undo", "object" => child_message} = message) do
+  def filter(%{"type" => "Undo", "object" => object} = activity) do
-    with {:ok, _} <- filter(child_message) do
+    with {:ok, _} <- filter(object) do
-      {:ok, message}
+      {:ok, activity}
     else
       {:reject, _} = e -> e
     end
   end
 
-  def filter(%{"type" => message_type} = message) do
+  def filter(%{"type" => activity_type} = activity) do
     with accepted_vocabulary <- Pleroma.Config.get([:mrf_vocabulary, :accept]),
          rejected_vocabulary <- Pleroma.Config.get([:mrf_vocabulary, :reject]),
          {_, true} <-
            {:accepted,
-            Enum.empty?(accepted_vocabulary) || Enum.member?(accepted_vocabulary, message_type)},
+            Enum.empty?(accepted_vocabulary) || Enum.member?(accepted_vocabulary, activity_type)},
          {_, false} <-
            {:rejected,
-            length(rejected_vocabulary) > 0 && Enum.member?(rejected_vocabulary, message_type)},
+            length(rejected_vocabulary) > 0 && Enum.member?(rejected_vocabulary, activity_type)},
-         {:ok, _} <- filter(message["object"]) do
+         {:ok, _} <- filter(activity["object"]) do
-      {:ok, message}
+      {:ok, activity}
     else
       {:reject, _} = e -> e
-      {:accepted, _} -> {:reject, "[VocabularyPolicy] #{message_type} not in accept list"}
+      {:accepted, _} -> {:reject, "[VocabularyPolicy] #{activity_type} not in accept list"}
-      {:rejected, _} -> {:reject, "[VocabularyPolicy] #{message_type} in reject list"}
+      {:rejected, _} -> {:reject, "[VocabularyPolicy] #{activity_type} in reject list"}
     end
   end
 
-  def filter(message), do: {:ok, message}
+  def filter(activity), do: {:ok, activity}
 
   @impl true
   def describe,
@@ -46,20 +46,20 @@ defmodule Pleroma.Web.ActivityPub.MRF.VocabularyPolicy do
       key: :mrf_vocabulary,
       related_policy: "Pleroma.Web.ActivityPub.MRF.VocabularyPolicy",
       label: "MRF Vocabulary",
-      description: "Filter messages which belong to certain activity vocabularies",
+      description: "Filter activities which belong to certain activity vocabularies",
       children: [
         %{
           key: :accept,
           type: {:list, :string},
           description:
-            "A list of ActivityStreams terms to accept. If empty, all supported messages are accepted.",
+            "A list of ActivityStreams terms to accept. If empty, all supported activities are accepted.",
           suggestions: ["Create", "Follow", "Mention", "Announce", "Like"]
         },
         %{
           key: :reject,
           type: {:list, :string},
           description:
-            "A list of ActivityStreams terms to reject. If empty, no messages are rejected.",
+            "A list of ActivityStreams terms to reject. If empty, no activities are rejected.",
           suggestions: ["Create", "Follow", "Mention", "Announce", "Like"]
         }
       ]