No OneTemporary
Actions

Authored By

Unknown

Size

22 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/pleroma/object/updater.ex b/lib/pleroma/object/updater.ex
	index 6381320bd..ab38d3ed2 100644
	--- a/lib/pleroma/object/updater.ex
	+++ b/lib/pleroma/object/updater.ex
	@@ -1,240 +1,240 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Object.Updater do
	require Pleroma.Constants

	def update_content_fields(orig_object_data, updated_object) do
	Pleroma.Constants.status_updatable_fields()
	\|> Enum.reduce(
	%{data: orig_object_data, updated: false},
	fn field, %{data: data, updated: updated} ->
	updated =
	updated or
	(field != "updated" and
	Map.get(updated_object, field) != Map.get(orig_object_data, field))

	data =
	if Map.has_key?(updated_object, field) do
	Map.put(data, field, updated_object[field])
	else
	Map.drop(data, [field])
	end

	%{data: data, updated: updated}
	end
	)
	end

	def maybe_history(object) do
	with history <- Map.get(object, "formerRepresentations"),
	true <- is_map(history),
	"OrderedCollection" <- Map.get(history, "type"),
	true <- is_list(Map.get(history, "orderedItems")),
	true <- is_integer(Map.get(history, "totalItems")) do
	history
	else
	_ -> nil
	end
	end

	def history_for(object) do
	with history when not is_nil(history) <- maybe_history(object) do
	history
	else
	_ -> history_skeleton()
	end
	end

	defp history_skeleton do
	%{
	"type" => "OrderedCollection",
	"totalItems" => 0,
	"orderedItems" => []
	}
	end

	def maybe_update_history(
	updated_object,
	orig_object_data,
	opts
	) do
	updated = opts[:updated]
	use_history_in_new_object? = opts[:use_history_in_new_object?]

	if not updated do
	%{updated_object: updated_object, used_history_in_new_object?: false}
	else
	# Put edit history
	# Note that we may have got the edit history by first fetching the object
	{new_history, used_history_in_new_object?} =
	with true <- use_history_in_new_object?,
	updated_history when not is_nil(updated_history) <- maybe_history(opts[:new_data]) do
	{updated_history, true}
	else
	_ ->
	history = history_for(orig_object_data)

	latest_history_item =
	orig_object_data
	\|> Map.drop(["id", "formerRepresentations"])

	updated_history =
	history
	\|> Map.put("orderedItems", [latest_history_item \| history["orderedItems"]])
	\|> Map.put("totalItems", history["totalItems"] + 1)

	{updated_history, false}
	end

	updated_object =
	updated_object
	\|> Map.put("formerRepresentations", new_history)

	%{updated_object: updated_object, used_history_in_new_object?: used_history_in_new_object?}
	end
	end

	defp maybe_update_poll(to_be_updated, updated_object) do
	choice_key = fn data ->
	if Map.has_key?(data, "anyOf"), do: "anyOf", else: "oneOf"
	end

	with true <- to_be_updated["type"] == "Question",
	key <- choice_key.(updated_object),
	true <- key == choice_key.(to_be_updated),
	orig_choices <- to_be_updated[key] \|> Enum.map(&Map.drop(&1, ["replies"])),
	new_choices <- updated_object[key] \|> Enum.map(&Map.drop(&1, ["replies"])),
	true <- orig_choices == new_choices do
	# Choices are the same, but counts are different
	to_be_updated
	\|> Map.put(key, updated_object[key])
	else
	# Choices (or vote type) have changed, do not allow this
	_ -> to_be_updated
	end
	end

	# This calculates the data to be sent as the object of an Update.
	# new_data's formerRepresentations is not considered.
	# formerRepresentations is added to the returned data.
	def make_update_object_data(original_data, new_data, date) do
	%{data: updated_data, updated: updated} =
	original_data
	\|> update_content_fields(new_data)

	if not updated do
	updated_data
	else
	%{updated_object: updated_data} =
	updated_data
	\|> maybe_update_history(original_data, updated: updated, use_history_in_new_object?: false)

	updated_data
	\|> Map.put("updated", date)
	end
	end

	# This calculates the data of the new Object from an Update.
	# new_data's formerRepresentations is considered.
	def make_new_object_data_from_update_object(original_data, new_data) do
	update_is_reasonable =
	with {_, updated} when not is_nil(updated) <- {:cur_updated, new_data["updated"]},
	{_, {:ok, updated_time, _}} <- {:cur_updated, DateTime.from_iso8601(updated)},
	{_, last_updated} when not is_nil(last_updated) <-
	{:last_updated, original_data["updated"] \|\| original_data["published"]},
	{_, {:ok, last_updated_time, _}} <-
	{:last_updated, DateTime.from_iso8601(last_updated)},
	:gt <- DateTime.compare(updated_time, last_updated_time) do
	:update_everything
	else
	# only allow poll updates
	{:cur_updated, _} -> :no_content_update
	:eq -> :no_content_update
	# allow all updates
	{:last_updated, _} -> :update_everything
	# allow no updates
	_ -> false
	end

	%{
	updated_object: updated_data,
	used_history_in_new_object?: used_history_in_new_object?,
	updated: updated
	} =
	if update_is_reasonable == :update_everything do
	%{data: updated_data, updated: updated} =
	original_data
	\|> update_content_fields(new_data)

	updated_data
	\|> maybe_update_history(original_data,
	updated: updated,
	use_history_in_new_object?: true,
	new_data: new_data
	)
	\|> Map.put(:updated, updated)
	else
	%{
	updated_object: original_data,
	used_history_in_new_object?: false,
	updated: false
	}
	end

	updated_data =
	if update_is_reasonable != false do
	updated_data
	\|> maybe_update_poll(new_data)
	else
	updated_data
	end

	%{
	updated_data: updated_data,
	updated: updated,
	used_history_in_new_object?: used_history_in_new_object?
	}
	end

	- defp for_each_history_item(%{"orderedItems" => items} = history, _object, fun) do
	+ def for_each_history_item(%{"orderedItems" => items} = history, _object, fun) do
	new_items =
	Enum.map(items, fun)
	\|> Enum.reduce_while(
	{:ok, []},
	fn
	{:ok, item}, {:ok, acc} -> {:cont, {:ok, acc ++ [item]}}
	e, _acc -> {:halt, e}
	end
	)

	case new_items do
	{:ok, items} -> {:ok, Map.put(history, "orderedItems", items)}
	e -> e
	end
	end

	- defp for_each_history_item(history, _, _) do
	+ def for_each_history_item(history, _, _) do
	{:ok, history}
	end

	def do_with_history(object, fun) do
	with history <- object["formerRepresentations"],
	object <- Map.drop(object, ["formerRepresentations"]),
	{_, {:ok, object}} <- {:main_body, fun.(object)},
	{_, {:ok, history}} <- {:history_items, for_each_history_item(history, object, fun)} do
	object =
	if history do
	Map.put(object, "formerRepresentations", history)
	else
	object
	end

	{:ok, object}
	else
	{:main_body, e} -> e
	{:history_items, e} -> e
	end
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/mrf.ex b/lib/pleroma/web/activity_pub/mrf.ex
	index 323ecdbf1..ff9f84497 100644
	--- a/lib/pleroma/web/activity_pub/mrf.ex
	+++ b/lib/pleroma/web/activity_pub/mrf.ex
	@@ -1,174 +1,217 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.MRF do
	require Logger

	@behaviour Pleroma.Web.ActivityPub.MRF.PipelineFiltering

	@mrf_config_descriptions [
	%{
	group: :pleroma,
	key: :mrf,
	tab: :mrf,
	label: "MRF",
	type: :group,
	description: "General MRF settings",
	children: [
	%{
	key: :policies,
	type: [:module, {:list, :module}],
	description:
	"A list of MRF policies enabled. Module names are shortened (removed leading `Pleroma.Web.ActivityPub.MRF.` part), but on adding custom module you need to use full name.",
	suggestions: {:list_behaviour_implementations, Pleroma.Web.ActivityPub.MRF.Policy}
	},
	%{
	key: :transparency,
	label: "MRF transparency",
	type: :boolean,
	description:
	"Make the content of your Message Rewrite Facility settings public (via nodeinfo)"
	},
	%{
	key: :transparency_exclusions,
	label: "MRF transparency exclusions",
	type: {:list, :tuple},
	key_placeholder: "instance",
	value_placeholder: "reason",
	description:
	"Exclude specific instance names from MRF transparency. The use of the exclusions feature will be disclosed in nodeinfo as a boolean value. You can also provide a reason for excluding these instance names. The instances and reasons won't be publicly disclosed.",
	suggestions: [
	"exclusion.com"
	]
	}
	]
	}
	]

	@default_description %{
	label: "",
	description: ""
	}

	@required_description_keys [:key, :related_policy]

	+ def filter_one(policy, message) do
	+ should_plug_history? =
	+ if function_exported?(policy, :history_awareness, 0) do
	+ policy.history_awareness()
	+ else
	+ :manual
	+ end
	+ \|> Kernel.==(:auto)
	+
	+ if not should_plug_history? do
	+ policy.filter(message)
	+ else
	+ main_result = policy.filter(message)
	+
	+ with {_, {:ok, main_message}} <- {:main, main_result},
	+ {_,
	+ %{
	+ "formerRepresentations" => %{
	+ "orderedItems" => [_ \| _]
	+ }
	+ }} = {_, object} <- {:object, message["object"]},
	+ {_, {:ok, new_history}} <-
	+ {:history,
	+ Pleroma.Object.Updater.for_each_history_item(
	+ object["formerRepresentations"],
	+ object,
	+ fn item ->
	+ with {:ok, filtered} <- policy.filter(Map.put(message, "object", item)) do
	+ {:ok, filtered["object"]}
	+ else
	+ e -> e
	+ end
	+ end
	+ )} do
	+ {:ok, put_in(main_message, ["object", "formerRepresentations"], new_history)}
	+ else
	+ {:main, _} -> main_result
	+ {:object, _} -> main_result
	+ {:history, e} -> e
	+ end
	+ end
	+ end
	+
	def filter(policies, %{} = message) do
	policies
	\|> Enum.reduce({:ok, message}, fn
	- policy, {:ok, message} -> policy.filter(message)
	+ policy, {:ok, message} -> filter_one(policy, message)
	_, error -> error
	end)
	end

	def filter(%{} = object), do: get_policies() \|> filter(object)

	@impl true
	def pipeline_filter(%{} = message, meta) do
	object = meta[:object_data]
	ap_id = message["object"]

	if object && ap_id do
	with {:ok, message} <- filter(Map.put(message, "object", object)) do
	meta = Keyword.put(meta, :object_data, message["object"])
	{:ok, Map.put(message, "object", ap_id), meta}
	else
	{err, message} -> {err, message, meta}
	end
	else
	{err, message} = filter(message)

	{err, message, meta}
	end
	end

	def get_policies do
	Pleroma.Config.get([:mrf, :policies], [])
	\|> get_policies()
	\|> Enum.concat([Pleroma.Web.ActivityPub.MRF.HashtagPolicy])
	end

	defp get_policies(policy) when is_atom(policy), do: [policy]
	defp get_policies(policies) when is_list(policies), do: policies
	defp get_policies(_), do: []

	@spec subdomains_regex([String.t()]) :: [Regex.t()]
	def subdomains_regex(domains) when is_list(domains) do
	for domain <- domains, do: ~r(^#{String.replace(domain, ".", "(.\\.)*")}$)i
	end

	@spec subdomain_match?([Regex.t()], String.t()) :: boolean()
	def subdomain_match?(domains, host) do
	Enum.any?(domains, fn domain -> Regex.match?(domain, host) end)
	end

	@spec instance_list_from_tuples([{String.t(), String.t()}]) :: [String.t()]
	def instance_list_from_tuples(list) do
	Enum.map(list, fn {instance, _} -> instance end)
	end

	def describe(policies) do
	{:ok, policy_configs} =
	policies
	\|> Enum.reduce({:ok, %{}}, fn
	policy, {:ok, data} ->
	{:ok, policy_data} = policy.describe()
	{:ok, Map.merge(data, policy_data)}

	_, error ->
	error
	end)

	mrf_policies =
	get_policies()
	\|> Enum.map(fn policy -> to_string(policy) \|> String.split(".") \|> List.last() end)

	exclusions = Pleroma.Config.get([:mrf, :transparency_exclusions])

	base =
	%{
	mrf_policies: mrf_policies,
	exclusions: length(exclusions) > 0
	}
	\|> Map.merge(policy_configs)

	{:ok, base}
	end

	def describe, do: get_policies() \|> describe()

	def config_descriptions do
	Pleroma.Web.ActivityPub.MRF.Policy
	\|> Pleroma.Docs.Generator.list_behaviour_implementations()
	\|> config_descriptions()
	end

	def config_descriptions(policies) do
	Enum.reduce(policies, @mrf_config_descriptions, fn policy, acc ->
	if function_exported?(policy, :config_description, 0) do
	description =
	@default_description
	\|> Map.merge(policy.config_description)
	\|> Map.put(:group, :pleroma)
	\|> Map.put(:tab, :mrf)
	\|> Map.put(:type, :group)

	if Enum.all?(@required_description_keys, &Map.has_key?(description, &1)) do
	[description \| acc]
	else
	Logger.warn(
	"#{policy} config description doesn't have one or all required keys #{inspect(@required_description_keys)}"
	)

	acc
	end
	else
	Logger.debug(
	"#{policy} is excluded from config descriptions, because does not implement `config_description/0` method."
	)

	acc
	end
	end)
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/mrf/ensure_re_prepended.ex b/lib/pleroma/web/activity_pub/mrf/ensure_re_prepended.ex
	index 51596c09f..a148cc1e7 100644
	--- a/lib/pleroma/web/activity_pub/mrf/ensure_re_prepended.ex
	+++ b/lib/pleroma/web/activity_pub/mrf/ensure_re_prepended.ex
	@@ -1,45 +1,47 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.MRF.EnsureRePrepended do
	alias Pleroma.Object

	@moduledoc "Ensure a re: is prepended on replies to a post with a Subject"
	@behaviour Pleroma.Web.ActivityPub.MRF.Policy

	@reply_prefix Regex.compile!("^re:[[:space:]]*", [:caseless])

	+ def history_awareness, do: :auto
	+
	def filter_by_summary(
	%{data: %{"summary" => parent_summary}} = _in_reply_to,
	%{"summary" => child_summary} = child
	)
	when not is_nil(child_summary) and byte_size(child_summary) > 0 and
	not is_nil(parent_summary) and byte_size(parent_summary) > 0 do
	if (child_summary == parent_summary and not Regex.match?(@reply_prefix, child_summary)) or
	(Regex.match?(@reply_prefix, parent_summary) &&
	Regex.replace(@reply_prefix, parent_summary, "") == child_summary) do
	Map.put(child, "summary", "re: " <> child_summary)
	else
	child
	end
	end

	def filter_by_summary(_in_reply_to, child), do: child

	- def filter(%{"type" => "Create", "object" => child_object} = object)
	- when is_map(child_object) do
	+ def filter(%{"type" => type, "object" => child_object} = object)
	+ when type in ["Create", "Update"] and is_map(child_object) do
	child =
	child_object["inReplyTo"]
	\|> Object.normalize(fetch: false)
	\|> filter_by_summary(child_object)

	object = Map.put(object, "object", child)

	{:ok, object}
	end

	def filter(object), do: {:ok, object}

	def describe, do: {:ok, %{}}
	end
	diff --git a/lib/pleroma/web/activity_pub/mrf/policy.ex b/lib/pleroma/web/activity_pub/mrf/policy.ex
	index 0ac250c3d..0234de4d5 100644
	--- a/lib/pleroma/web/activity_pub/mrf/policy.ex
	+++ b/lib/pleroma/web/activity_pub/mrf/policy.ex
	@@ -1,16 +1,17 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.MRF.Policy do
	@callback filter(Map.t()) :: {:ok \| :reject, Map.t()}
	@callback describe() :: {:ok \| :error, Map.t()}
	@callback config_description() :: %{
	optional(:children) => [map()],
	key: atom(),
	related_policy: String.t(),
	label: String.t(),
	description: String.t()
	}
	- @optional_callbacks config_description: 0
	+ @callback history_awareness() :: :auto \| :manual
	+ @optional_callbacks config_description: 0, history_awareness: 0
	end
	diff --git a/test/pleroma/web/activity_pub/mrf/ensure_re_prepended_test.exs b/test/pleroma/web/activity_pub/mrf/ensure_re_prepended_test.exs
	index bc2f09e29..859e6f1e9 100644
	--- a/test/pleroma/web/activity_pub/mrf/ensure_re_prepended_test.exs
	+++ b/test/pleroma/web/activity_pub/mrf/ensure_re_prepended_test.exs
	@@ -1,92 +1,141 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.MRF.EnsureRePrependedTest do
	use Pleroma.DataCase, async: true

	alias Pleroma.Activity
	alias Pleroma.Object
	+ alias Pleroma.Web.ActivityPub.MRF
	alias Pleroma.Web.ActivityPub.MRF.EnsureRePrepended

	describe "rewrites summary" do
	test "it adds `re:` to summary object when child summary and parent summary equal" do
	message = %{
	"type" => "Create",
	"object" => %{
	"summary" => "object-summary",
	"inReplyTo" => %Activity{object: %Object{data: %{"summary" => "object-summary"}}}
	}
	}

	assert {:ok, res} = EnsureRePrepended.filter(message)
	assert res["object"]["summary"] == "re: object-summary"
	end

	test "it adds `re:` to summary object when child summary containts re-subject of parent summary " do
	message = %{
	"type" => "Create",
	"object" => %{
	"summary" => "object-summary",
	"inReplyTo" => %Activity{object: %Object{data: %{"summary" => "re: object-summary"}}}
	}
	}

	assert {:ok, res} = EnsureRePrepended.filter(message)
	assert res["object"]["summary"] == "re: object-summary"
	end
	+
	+ test "it adds `re:` to history" do
	+ message = %{
	+ "type" => "Create",
	+ "object" => %{
	+ "summary" => "object-summary",
	+ "inReplyTo" => %Activity{object: %Object{data: %{"summary" => "object-summary"}}},
	+ "formerRepresentations" => %{
	+ "orderedItems" => [
	+ %{
	+ "summary" => "object-summary",
	+ "inReplyTo" => %Activity{object: %Object{data: %{"summary" => "object-summary"}}}
	+ }
	+ ]
	+ }
	+ }
	+ }
	+
	+ assert {:ok, res} = MRF.filter_one(EnsureRePrepended, message)
	+ assert res["object"]["summary"] == "re: object-summary"
	+
	+ assert Enum.at(res["object"]["formerRepresentations"]["orderedItems"], 0)["summary"] ==
	+ "re: object-summary"
	+ end
	+
	+ test "it accepts Updates" do
	+ message = %{
	+ "type" => "Update",
	+ "object" => %{
	+ "summary" => "object-summary",
	+ "inReplyTo" => %Activity{object: %Object{data: %{"summary" => "object-summary"}}},
	+ "formerRepresentations" => %{
	+ "orderedItems" => [
	+ %{
	+ "summary" => "object-summary",
	+ "inReplyTo" => %Activity{object: %Object{data: %{"summary" => "object-summary"}}}
	+ }
	+ ]
	+ }
	+ }
	+ }
	+
	+ assert {:ok, res} = MRF.filter_one(EnsureRePrepended, message)
	+ assert res["object"]["summary"] == "re: object-summary"
	+
	+ assert Enum.at(res["object"]["formerRepresentations"]["orderedItems"], 0)["summary"] ==
	+ "re: object-summary"
	+ end
	end

	describe "skip filter" do
	- test "it skip if type isn't 'Create'" do
	+ test "it skip if type isn't 'Create' or 'Update'" do
	message = %{
	"type" => "Annotation",
	"object" => %{"summary" => "object-summary"}
	}

	assert {:ok, res} = EnsureRePrepended.filter(message)
	assert res == message
	end

	test "it skip if summary is empty" do
	message = %{
	"type" => "Create",
	"object" => %{
	"inReplyTo" => %Activity{object: %Object{data: %{"summary" => "summary"}}}
	}
	}

	assert {:ok, res} = EnsureRePrepended.filter(message)
	assert res == message
	end

	test "it skip if inReplyTo is empty" do
	message = %{"type" => "Create", "object" => %{"summary" => "summary"}}
	assert {:ok, res} = EnsureRePrepended.filter(message)
	assert res == message
	end

	test "it skip if parent and child summary isn't equal" do
	message = %{
	"type" => "Create",
	"object" => %{
	"summary" => "object-summary",
	"inReplyTo" => %Activity{object: %Object{data: %{"summary" => "summary"}}}
	}
	}

	assert {:ok, res} = EnsureRePrepended.filter(message)
	assert res == message
	end

	test "it skips if the object is only a reference" do
	message = %{
	"type" => "Create",
	"object" => "somereference"
	}

	assert {:ok, res} = EnsureRePrepended.filter(message)
	assert res == message
	end
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Sat, Oct 31, 11:51 AM (19 h, 11 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1801375
Default Alt Text: (22 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions