No OneTemporary
Actions

Size

23 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/pleroma/emoji.ex b/lib/pleroma/emoji.ex
	index 8c0257ef4..9fead1010 100644
	--- a/lib/pleroma/emoji.ex
	+++ b/lib/pleroma/emoji.ex
	@@ -1,221 +1,238 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Emoji do
	@moduledoc """
	This GenServer stores in an ETS table the list of the loaded emojis,
	and also allows to reload the list at runtime.
	"""
	use GenServer

	alias Pleroma.Emoji.Combinations
	alias Pleroma.Emoji.Loader
	+ alias Pleroma.Utils.URIEncoding
	+ alias Pleroma.Web.Endpoint

	require Logger

	@ets __MODULE__.Ets
	@ets_options [
	:ordered_set,
	:protected,
	:named_table,
	{:read_concurrency, true}
	]

	defstruct [:code, :file, :tags, :safe_code, :safe_file]

	@type t :: %__MODULE__{}

	@doc "Build emoji struct"
	def build({code, file, tags}) do
	%__MODULE__{
	code: code,
	file: file,
	tags: tags,
	safe_code: Pleroma.HTML.strip_tags(code),
	safe_file: Pleroma.HTML.strip_tags(file)
	}
	end

	def build({code, file}), do: build({code, file, []})

	@doc false
	def start_link(_) do
	GenServer.start_link(__MODULE__, [], name: __MODULE__)
	end

	@doc "Reloads the emojis from disk."
	@spec reload() :: :ok
	def reload do
	GenServer.call(__MODULE__, :reload)
	end

	@doc "Returns the path of the emoji `name`."
	@spec get(String.t()) :: Pleroma.Emoji.t() \| nil
	def get(name) do
	name = maybe_strip_name(name)

	case :ets.lookup(@ets, name) do
	[{_, emoji}] -> emoji
	_ -> nil
	end
	end

	@spec exist?(String.t()) :: boolean()
	def exist?(name), do: not is_nil(get(name))

	@doc "Returns all the emojos!!"
	@spec get_all() :: list({String.t(), String.t(), String.t()})
	def get_all do
	:ets.tab2list(@ets)
	end

	@doc "Clear out old emojis"
	def clear_all, do: :ets.delete_all_objects(@ets)

	@doc false
	def init(_) do
	@ets = :ets.new(@ets, @ets_options)
	GenServer.cast(self(), :reload)
	{:ok, nil}
	end

	@doc false
	def handle_cast(:reload, state) do
	update_emojis(Loader.load())
	{:noreply, state}
	end

	@doc false
	def handle_call(:reload, _from, state) do
	update_emojis(Loader.load())
	{:reply, :ok, state}
	end

	@doc false
	def terminate(_, _) do
	:ok
	end

	@doc false
	def code_change(_old_vsn, state, _extra) do
	update_emojis(Loader.load())
	{:ok, state}
	end

	defp update_emojis(emojis) do
	:ets.insert(@ets, emojis)
	end

	@external_resource "lib/pleroma/emoji-test.txt"

	regional_indicators =
	Enum.map(127_462..127_487, fn codepoint ->
	<<codepoint::utf8>>
	end)

	emojis =
	@external_resource
	\|> File.read!()
	\|> String.split("\n")
	\|> Enum.filter(fn line ->
	line != "" and not String.starts_with?(line, "#") and
	String.contains?(line, "fully-qualified")
	end)
	\|> Enum.map(fn line ->
	line
	\|> String.split(";", parts: 2)
	\|> hd()
	\|> String.trim()
	\|> String.split()
	\|> Enum.map(fn codepoint ->
	<<String.to_integer(codepoint, 16)::utf8>>
	end)
	\|> Enum.join()
	end)
	\|> Enum.uniq()

	emojis = emojis ++ regional_indicators

	for emoji <- emojis do
	def unicode?(unquote(emoji)), do: true
	end

	def unicode?(_), do: false

	@emoji_regex ~r/:[A-Za-z0-9_-]+(@.+)?:/

	def custom?(s) when is_binary(s), do: Regex.match?(@emoji_regex, s)

	def custom?(_), do: false

	def maybe_strip_name(name) when is_binary(name), do: String.trim(name, ":")

	def maybe_strip_name(name), do: name

	def maybe_quote(name) when is_binary(name) do
	if unicode?(name) do
	name
	else
	if String.starts_with?(name, ":") do
	name
	else
	":#{name}:"
	end
	end
	end

	def maybe_quote(name), do: name

	def emoji_url(%{"type" => "EmojiReact", "content" => _, "tag" => []}), do: nil

	def emoji_url(%{"type" => "EmojiReact", "content" => emoji, "tag" => tags}) do
	emoji = maybe_strip_name(emoji)

	tag =
	tags
	\|> Enum.find(fn tag ->
	tag["type"] == "Emoji" && !is_nil(tag["name"]) && tag["name"] == emoji
	end)

	if is_nil(tag) do
	nil
	else
	tag
	\|> Map.get("icon")
	\|> Map.get("url")
	end
	end

	def emoji_url(_), do: nil

	+ @spec local_url(String.t() \| nil) :: String.t() \| nil
	+ def local_url(nil), do: nil
	+
	+ def local_url("http" <> _ = url) do
	+ URIEncoding.encode_url(url)
	+ end
	+
	+ def local_url("/" <> _ = path) do
	+ URIEncoding.encode_url(Endpoint.url() <> path, bypass_decode: true)
	+ end
	+
	+ def local_url(path) when is_binary(path) do
	+ local_url("/" <> path)
	+ end
	+
	def build_emoji_tag({name, url}) do
	- url = URI.encode(url)
	+ url = URIEncoding.encode_url(url)

	%{
	"icon" => %{"url" => "#{url}", "type" => "Image"},
	"name" => ":" <> name <> ":",
	"type" => "Emoji",
	"updated" => "1970-01-01T00:00:00Z",
	"id" => url
	}
	end

	def emoji_name_with_instance(name, url) do
	url = url \|> URI.parse() \|> Map.get(:host)
	"#{name}@#{url}"
	end

	emoji_qualification_map =
	emojis
	\|> Enum.filter(&String.contains?(&1, "\uFE0F"))
	\|> Combinations.variate_emoji_qualification()

	for {qualified, unqualified_list} <- emoji_qualification_map do
	for unqualified <- unqualified_list do
	def fully_qualify_emoji(unquote(unqualified)), do: unquote(qualified)
	end
	end

	def fully_qualify_emoji(emoji), do: emoji
	end
	diff --git a/lib/pleroma/emoji/formatter.ex b/lib/pleroma/emoji/formatter.ex
	index 87fd35f13..9238bf912 100644
	--- a/lib/pleroma/emoji/formatter.ex
	+++ b/lib/pleroma/emoji/formatter.ex
	@@ -1,52 +1,51 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Emoji.Formatter do
	alias Pleroma.Emoji
	alias Pleroma.HTML
	- alias Pleroma.Web.Endpoint
	alias Pleroma.Web.MediaProxy

	def emojify(text) do
	emojify(text, Emoji.get_all())
	end

	def emojify(text, nil), do: text

	def emojify(text, emoji, strip \\ false) do
	Enum.reduce(emoji, text, fn
	{_, %Emoji{safe_code: emoji, safe_file: file}}, text ->
	String.replace(text, ":#{emoji}:", prepare_emoji_html(emoji, file, strip))

	{unsafe_emoji, unsafe_file}, text ->
	emoji = HTML.strip_tags(unsafe_emoji)
	file = HTML.strip_tags(unsafe_file)
	String.replace(text, ":#{emoji}:", prepare_emoji_html(emoji, file, strip))
	end)
	\|> HTML.filter_tags()
	end

	defp prepare_emoji_html(_emoji, _file, true), do: ""

	defp prepare_emoji_html(emoji, file, _strip) do
	"<img class='emoji' alt='#{emoji}' title='#{emoji}' src='#{MediaProxy.url(file)}' />"
	end

	def demojify(text) do
	emojify(text, Emoji.get_all(), true)
	end

	def demojify(text, nil), do: text

	@doc "Outputs a list of the emoji-Maps in a text"
	def get_emoji_map(text) when is_binary(text) do
	Emoji.get_all()
	\|> Enum.filter(fn {emoji, %Emoji{}} -> String.contains?(text, ":#{emoji}:") end)
	\|> Enum.reduce(%{}, fn {name, %Emoji{file: file}}, acc ->
	- Map.put(acc, name, to_string(URI.merge(Endpoint.url(), file)))
	+ Map.put(acc, name, Emoji.local_url(file))
	end)
	end

	def get_emoji_map(_), do: %{}
	end
	diff --git a/lib/pleroma/web/activity_pub/builder.ex b/lib/pleroma/web/activity_pub/builder.ex
	index 4146fd6ab..167c769a9 100644
	--- a/lib/pleroma/web/activity_pub/builder.ex
	+++ b/lib/pleroma/web/activity_pub/builder.ex
	@@ -1,426 +1,425 @@
	# 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.Builder do
	@moduledoc """
	This module builds the objects. Meant to be used for creating local objects.

	This module encodes our addressing policies and general shape of our objects.
	"""

	alias Pleroma.Activity
	alias Pleroma.Emoji
	alias Pleroma.Object
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.Relay
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.ActivityPub.Visibility
	alias Pleroma.Web.CommonAPI.ActivityDraft
	- alias Pleroma.Web.Endpoint

	require Pleroma.Constants

	def accept_or_reject(actor, activity, type) do
	data = %{
	"id" => Utils.generate_activity_id(),
	"actor" => actor.ap_id,
	"type" => type,
	"object" => activity.data["id"],
	"to" => [activity.actor]
	}

	{:ok, data, []}
	end

	@spec reject(User.t(), Activity.t()) :: {:ok, map(), keyword()}
	def reject(actor, rejected_activity) do
	accept_or_reject(actor, rejected_activity, "Reject")
	end

	@spec accept(User.t(), Activity.t()) :: {:ok, map(), keyword()}
	def accept(actor, accepted_activity) do
	accept_or_reject(actor, accepted_activity, "Accept")
	end

	@spec follow(User.t(), User.t()) :: {:ok, map(), keyword()}
	def follow(follower, followed) do
	data = %{
	"id" => Utils.generate_activity_id(),
	"actor" => follower.ap_id,
	"type" => "Follow",
	"object" => followed.ap_id,
	"to" => [followed.ap_id]
	}

	{:ok, data, []}
	end

	defp unicode_emoji_react(_object, data, emoji) do
	data
	\|> Map.put("content", emoji)
	\|> Map.put("type", "EmojiReact")
	end

	defp add_emoji_content(data, emoji, url) do
	tag = [
	Emoji.build_emoji_tag({Emoji.maybe_strip_name(emoji), url})
	]

	data
	\|> Map.put("content", Emoji.maybe_quote(emoji))
	\|> Map.put("type", "EmojiReact")
	\|> Map.put("tag", tag)
	end

	defp remote_custom_emoji_react(
	%{data: %{"reactions" => existing_reactions}},
	data,
	emoji
	) do
	[emoji_code, instance] = String.split(Emoji.maybe_strip_name(emoji), "@")

	matching_reaction =
	Enum.find(
	existing_reactions,
	fn [name, _, url] ->
	if url != nil do
	url = URI.parse(url)
	url.host == instance && name == emoji_code
	end
	end
	)

	if matching_reaction do
	[name, _, url] = matching_reaction
	add_emoji_content(data, name, url)
	else
	{:error, "Could not react"}
	end
	end

	defp remote_custom_emoji_react(_object, _data, _emoji) do
	{:error, "Could not react"}
	end

	defp local_custom_emoji_react(data, emoji) do
	with %{file: path} = emojo <- Emoji.get(emoji) do
	- url = "#{Endpoint.url()}#{path}"
	+ url = Emoji.local_url(path)
	add_emoji_content(data, emojo.code, url)
	else
	_ -> {:error, "Emoji does not exist"}
	end
	end

	defp custom_emoji_react(object, data, emoji) do
	if String.contains?(emoji, "@") do
	remote_custom_emoji_react(object, data, emoji)
	else
	local_custom_emoji_react(data, emoji)
	end
	end

	@spec emoji_react(User.t(), Object.t(), String.t()) :: {:ok, map(), keyword()}
	def emoji_react(actor, object, emoji) do
	with {:ok, data, meta} <- object_action(actor, object) do
	data =
	if Emoji.unicode?(emoji) do
	unicode_emoji_react(object, data, emoji)
	else
	custom_emoji_react(object, data, emoji)
	end

	{:ok, data, meta}
	end
	end

	@spec undo(User.t(), Activity.t()) :: {:ok, map(), keyword()}
	def undo(actor, object) do
	{:ok,
	%{
	"id" => Utils.generate_activity_id(),
	"actor" => actor.ap_id,
	"type" => "Undo",
	"object" => object.data["id"],
	"to" => object.data["to"] \|\| [],
	"cc" => object.data["cc"] \|\| []
	}, []}
	end

	@spec delete(User.t(), String.t()) :: {:ok, map(), keyword()}
	def delete(actor, object_id) do
	object = Object.normalize(object_id, fetch: false)

	user = !object && User.get_cached_by_ap_id(object_id)

	to =
	case {object, user} do
	{%Object{}, _} ->
	# We are deleting an object, address everyone who was originally mentioned
	(object.data["to"] \|\| []) ++ (object.data["cc"] \|\| [])

	{_, %User{follower_address: follower_address}} ->
	# We are deleting a user, address the followers of that user
	[follower_address]
	end

	{:ok,
	%{
	"id" => Utils.generate_activity_id(),
	"actor" => actor.ap_id,
	"object" => object_id,
	"to" => to,
	"type" => "Delete"
	}, []}
	end

	def create(actor, object, recipients) do
	context =
	if is_map(object) do
	object["context"]
	else
	nil
	end

	{:ok,
	%{
	"id" => Utils.generate_activity_id(),
	"actor" => actor.ap_id,
	"to" => recipients,
	"object" => object,
	"type" => "Create",
	"published" => DateTime.utc_now() \|> DateTime.to_iso8601()
	}
	\|> Pleroma.Maps.put_if_present("context", context), []}
	end

	@spec note(ActivityDraft.t()) :: {:ok, map(), keyword()}
	def note(%ActivityDraft{} = draft) do
	data =
	%{
	"type" => "Note",
	"to" => draft.to,
	"cc" => draft.cc,
	"content" => draft.content_html,
	"summary" => draft.summary,
	"sensitive" => draft.sensitive,
	"context" => draft.context,
	"attachment" => draft.attachments,
	"actor" => draft.user.ap_id,
	"tag" => Keyword.values(draft.tags) \|> Enum.uniq()
	}
	\|> add_in_reply_to(draft.in_reply_to)
	\|> add_quote(draft.quote_post)
	\|> Map.merge(draft.extra)

	{:ok, data, []}
	end

	defp add_in_reply_to(object, nil), do: object

	defp add_in_reply_to(object, in_reply_to) do
	with %Object{} = in_reply_to_object <- Object.normalize(in_reply_to, fetch: false) do
	Map.put(object, "inReplyTo", in_reply_to_object.data["id"])
	else
	_ -> object
	end
	end

	defp add_quote(object, nil), do: object

	defp add_quote(object, quote_post) do
	with %Object{} = quote_object <- Object.normalize(quote_post, fetch: false) do
	Map.put(object, "quoteUrl", quote_object.data["id"])
	else
	_ -> object
	end
	end

	def chat_message(actor, recipient, content, opts \\ []) do
	basic = %{
	"id" => Utils.generate_object_id(),
	"actor" => actor.ap_id,
	"type" => "ChatMessage",
	"to" => [recipient],
	"content" => content,
	"published" => DateTime.utc_now() \|> DateTime.to_iso8601(),
	"emoji" => Emoji.Formatter.get_emoji_map(content)
	}

	case opts[:attachment] do
	%Object{data: attachment_data} ->
	{
	:ok,
	Map.put(basic, "attachment", attachment_data),
	[]
	}

	_ ->
	{:ok, basic, []}
	end
	end

	def answer(user, object, name) do
	{:ok,
	%{
	"type" => "Answer",
	"actor" => user.ap_id,
	"attributedTo" => user.ap_id,
	"cc" => [object.data["actor"]],
	"to" => [],
	"name" => name,
	"inReplyTo" => object.data["id"],
	"context" => object.data["context"],
	"published" => DateTime.utc_now() \|> DateTime.to_iso8601(),
	"id" => Utils.generate_object_id()
	}, []}
	end

	@spec tombstone(String.t(), String.t()) :: {:ok, map(), keyword()}
	def tombstone(actor, id) do
	{:ok,
	%{
	"id" => id,
	"actor" => actor,
	"type" => "Tombstone"
	}, []}
	end

	@spec like(User.t(), Object.t()) :: {:ok, map(), keyword()}
	def like(actor, object) do
	with {:ok, data, meta} <- object_action(actor, object) do
	data =
	data
	\|> Map.put("type", "Like")

	{:ok, data, meta}
	end
	end

	@spec update(User.t(), Object.t()) :: {:ok, map(), keyword()}
	def update(actor, object) do
	{to, cc} =
	if object["type"] in Pleroma.Constants.actor_types() do
	# User updates, always public
	{[Pleroma.Constants.as_public(), actor.follower_address], []}
	else
	# Status updates, follow the recipients in the object
	{object["to"] \|\| [], object["cc"] \|\| []}
	end

	{:ok,
	%{
	"id" => Utils.generate_activity_id(),
	"type" => "Update",
	"actor" => actor.ap_id,
	"object" => object,
	"to" => to,
	"cc" => cc
	}, []}
	end

	@spec block(User.t(), User.t(), map()) :: {:ok, map(), keyword()}
	def block(blocker, blocked, params \\ %{}) do
	{:ok,
	%{
	"id" => Utils.generate_activity_id(),
	"type" => "Block",
	"actor" => blocker.ap_id,
	"object" => blocked.ap_id,
	"to" => [blocked.ap_id]
	}, Keyword.new(params)}
	end

	@spec announce(User.t(), Object.t(), keyword()) :: {:ok, map(), keyword()}
	def announce(actor, object, options \\ []) do
	public? = Keyword.get(options, :public, false)

	to =
	cond do
	actor.ap_id == Relay.ap_id() ->
	[actor.follower_address]

	public? and Visibility.local_public?(object) ->
	[actor.follower_address, object.data["actor"], Utils.as_local_public()]

	public? ->
	[actor.follower_address, object.data["actor"], Pleroma.Constants.as_public()]

	true ->
	[actor.follower_address, object.data["actor"]]
	end

	{:ok,
	%{
	"id" => Utils.generate_activity_id(),
	"actor" => actor.ap_id,
	"object" => object.data["id"],
	"to" => to,
	"context" => object.data["context"],
	"type" => "Announce",
	"published" => Utils.make_date()
	}, []}
	end

	@spec object_action(User.t(), Object.t()) :: {:ok, map(), keyword()}
	defp object_action(actor, object) do
	object_actor = User.get_cached_by_ap_id(object.data["actor"])

	# Address the actor of the object, and our actor's follower collection if the post is public.
	to =
	if Visibility.public?(object) do
	[actor.follower_address, object.data["actor"]]
	else
	[object.data["actor"]]
	end

	# CC everyone who's been addressed in the object, except ourself and the object actor's
	# follower collection
	cc =
	(object.data["to"] ++ (object.data["cc"] \|\| []))
	\|> List.delete(actor.ap_id)
	\|> List.delete(object_actor.follower_address)

	{:ok,
	%{
	"id" => Utils.generate_activity_id(),
	"actor" => actor.ap_id,
	"object" => object.data["id"],
	"to" => to,
	"cc" => cc,
	"context" => object.data["context"]
	}, []}
	end

	@spec pin(User.t(), Object.t()) :: {:ok, map(), keyword()}
	def pin(%User{} = user, object) do
	{:ok,
	%{
	"id" => Utils.generate_activity_id(),
	"target" => pinned_url(user.nickname),
	"object" => object.data["id"],
	"actor" => user.ap_id,
	"type" => "Add",
	"to" => [Pleroma.Constants.as_public()],
	"cc" => [user.follower_address]
	}, []}
	end

	@spec unpin(User.t(), Object.t()) :: {:ok, map, keyword()}
	def unpin(%User{} = user, object) do
	{:ok,
	%{
	"id" => Utils.generate_activity_id(),
	"target" => pinned_url(user.nickname),
	"object" => object.data["id"],
	"actor" => user.ap_id,
	"type" => "Remove",
	"to" => [Pleroma.Constants.as_public()],
	"cc" => [user.follower_address]
	}, []}
	end

	defp pinned_url(nickname) when is_binary(nickname) do
	Pleroma.Web.Router.Helpers.activity_pub_url(Pleroma.Web.Endpoint, :pinned, nickname)
	end
	end
	diff --git a/lib/pleroma/web/mastodon_api/views/custom_emoji_view.ex b/lib/pleroma/web/mastodon_api/views/custom_emoji_view.ex
	index cd59ab946..6ef48e98a 100644
	--- a/lib/pleroma/web/mastodon_api/views/custom_emoji_view.ex
	+++ b/lib/pleroma/web/mastodon_api/views/custom_emoji_view.ex
	@@ -1,28 +1,27 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.CustomEmojiView do
	use Pleroma.Web, :view

	alias Pleroma.Emoji
	- alias Pleroma.Web.Endpoint

	def render("index.json", %{custom_emojis: custom_emojis}) do
	render_many(custom_emojis, __MODULE__, "show.json")
	end

	def render("show.json", %{custom_emoji: {shortcode, %Emoji{file: relative_url, tags: tags}}}) do
	- url = Endpoint.url() \|> URI.merge(relative_url) \|> to_string()
	+ url = Emoji.local_url(relative_url)

	%{
	"shortcode" => shortcode,
	"static_url" => url,
	"visible_in_picker" => true,
	"url" => url,
	"tags" => tags,
	# Assuming that a comma is authorized in the category name
	"category" => tags \|> List.delete("Custom") \|> Enum.join(",")
	}
	end
	end
	diff --git a/lib/pleroma/web/pleroma_api/views/bookmark_folder_view.ex b/lib/pleroma/web/pleroma_api/views/bookmark_folder_view.ex
	index 12decb816..29028781f 100644
	--- a/lib/pleroma/web/pleroma_api/views/bookmark_folder_view.ex
	+++ b/lib/pleroma/web/pleroma_api/views/bookmark_folder_view.ex
	@@ -1,42 +1,41 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2024 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.PleromaAPI.BookmarkFolderView do
	use Pleroma.Web, :view

	alias Pleroma.BookmarkFolder
	alias Pleroma.Emoji
	- alias Pleroma.Web.Endpoint

	def render("show.json", %{folder: %BookmarkFolder{} = folder}) do
	%{
	id: folder.id \|> to_string(),
	name: folder.name,
	emoji: folder.emoji,
	emoji_url: get_emoji_url(folder.emoji)
	}
	end

	def render("index.json", %{folders: folders} = opts) do
	render_many(folders, __MODULE__, "show.json", Map.delete(opts, :folders))
	end

	defp get_emoji_url(nil) do
	nil
	end

	defp get_emoji_url(emoji) do
	if Emoji.unicode?(emoji) do
	nil
	else
	emoji = Emoji.get(emoji)

	if emoji != nil do
	- Endpoint.url() \|> URI.merge(emoji.file) \|> to_string()
	+ Emoji.local_url(emoji.file)
	else
	nil
	end
	end
	end
	end
	diff --git a/test/pleroma/web/activity_pub/transmogrifier/emoji_tag_building_test.exs b/test/pleroma/web/activity_pub/transmogrifier/emoji_tag_building_test.exs
	index a6c5d689c..ff005b466 100644
	--- a/test/pleroma/web/activity_pub/transmogrifier/emoji_tag_building_test.exs
	+++ b/test/pleroma/web/activity_pub/transmogrifier/emoji_tag_building_test.exs
	@@ -1,14 +1,40 @@
	defmodule Pleroma.Web.ActivityPub.Transmogrifier.EmojiTagBuildingTest do
	use Pleroma.DataCase, async: true

	- alias Pleroma.Web.ActivityPub.Transmogrifier
	-
	test "it encodes the id to be a valid url" do
	name = "hanapog"
	url = "https://misskey.local.live/emojis/hana pog.png"

	tag = Pleroma.Emoji.build_emoji_tag({name, url})

	assert tag["id"] == "https://misskey.local.live/emojis/hana%20pog.png"
	end
	+
	+ test "it does not double-encode already encoded urls" do
	+ name = "hanapog"
	+ url = "https://misskey.local.live/emojis/hana%20pog.png"
	+
	+ tag = Pleroma.Emoji.build_emoji_tag({name, url})
	+
	+ assert tag["id"] == url
	+ end
	+
	+ test "it encodes disallowed path characters" do
	+ name = "hanapog"
	+ url = "https://example.com/emojis/hana[pog].png"
	+
	+ tag = Pleroma.Emoji.build_emoji_tag({name, url})
	+
	+ assert tag["id"] == "https://example.com/emojis/hana%5Bpog%5D.png"
	+ end
	+
	+ test "local_url does not decode percent in filenames" do
	+ url = Pleroma.Emoji.local_url("/emoji/hana%20pog.png")
	+
	+ assert url == Pleroma.Web.Endpoint.url() <> "/emoji/hana%2520pog.png"
	+
	+ tag = Pleroma.Emoji.build_emoji_tag({"hanapog", url})
	+
	+ assert tag["id"] == url
	+ end
	end

File Metadata

Mime Type: text/x-diff
Expires: Sat, Jul 18, 11:01 AM (21 h, 31 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1695054
Default Alt Text: (23 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions