Switch formatting checks to Elixir 1.15

.gitlab-ci.yml

@@ -169,9 +169,9 @@ unit-testing-1.13.4-otp-25-erratic:
     - mix ecto.migrate
     - mix test --only=erratic
 
-formatting-1.13:
+formatting-1.15:
   extends: .build_changes_policy
-  image: &formatting_elixir elixir:1.13-alpine
+  image: &formatting_elixir elixir:1.15-alpine
   stage: lint
   cache: *testing_cache_policy
   before_script: &current_bfr_script

lib/mix/tasks/pleroma/database.ex

@@ -351,7 +351,7 @@ def run(["set_text_search_config", tsconfig]) do
         )
       end
 
-      shell_info('Done.')
+      shell_info(~c"Done.")
     end
   end
 

lib/pleroma/emoji/pack.ex

@@ -416,10 +416,10 @@ defp downloadable?(pack) do
   end
 
   defp create_archive_and_cache(pack, hash) do
-    files = ['pack.json' | Enum.map(pack.files, fn {_, file} -> to_charlist(file) end)]
+    files = [~c"pack.json" | Enum.map(pack.files, fn {_, file} -> to_charlist(file) end)]
 
     {:ok, {_, result}} =
-      :zip.zip('#{pack.name}.zip', files, [:memory, cwd: to_charlist(pack.path)])
+      :zip.zip(~c"#{pack.name}.zip", files, [:memory, cwd: to_charlist(pack.path)])
 
     ttl_per_file = Pleroma.Config.get!([:emoji, :shared_pack_cache_seconds_per_file])
     overall_ttl = :timer.seconds(ttl_per_file * Enum.count(files))
@@ -586,7 +586,7 @@ defp unzip(archive, pack_info, remote_pack, local_pack) do
     with :ok <- File.mkdir_p!(local_pack.path) do
       files = Enum.map(remote_pack["files"], fn {_, path} -> to_charlist(path) end)
       # Fallback cannot contain a pack.json file
-      files = if pack_info[:fallback], do: files, else: ['pack.json' | files]
+      files = if pack_info[:fallback], do: files, else: [~c"pack.json" | files]
 
       :zip.unzip(archive, cwd: to_charlist(local_pack.path), file_list: files)
     end

lib/pleroma/object/updater.ex

@@ -134,7 +134,10 @@ def make_update_object_data(original_data, new_data, date) do
     else
       %{updated_object: updated_data} =
         updated_data
-        |> maybe_update_history(original_data, updated: updated, use_history_in_new_object?: false)
+        |> maybe_update_history(original_data,
+          updated: updated,
+          use_history_in_new_object?: false
+        )
 
       updated_data
       |> Map.put("updated", date)

lib/pleroma/user/backup.ex

@@ -197,12 +197,12 @@ defp wait_backup(backup, current_processed, task) do
   end
 
   @files [
-    'actor.json',
-    'outbox.json',
-    'likes.json',
-    'bookmarks.json',
-    'followers.json',
-    'following.json'
+    ~c"actor.json",
+    ~c"outbox.json",
+    ~c"likes.json",
+    ~c"bookmarks.json",
+    ~c"followers.json",
+    ~c"following.json"
   ]
   @spec export(Pleroma.User.Backup.t(), pid()) :: {:ok, String.t()} | :error
   def export(%__MODULE__{} = backup, caller_pid) do

lib/pleroma/web/api_spec/operations/search_operation.ex

@@ -79,7 +79,9 @@ def search_operation do
           %Schema{type: :string, enum: ["accounts", "hashtags", "statuses"]},
           "Search type"
         ),
-        Operation.parameter(:q, :query, %Schema{type: :string}, "The search query", required: true),
+        Operation.parameter(:q, :query, %Schema{type: :string}, "The search query",
+          required: true
+        ),
         Operation.parameter(
           :resolve,
           :query,

lib/pleroma/web/auth/ldap_authenticator.ex

@@ -110,7 +110,7 @@ defp register_user(connection, base, uid, name) do
         }
 
         params =
-          case List.keyfind(attributes, 'mail', 0) do
+          case List.keyfind(attributes, ~c"mail", 0) do
             {_, [mail]} -> Map.put_new(params, :email, :erlang.list_to_binary(mail))
             _ -> params
           end

lib/pleroma/web/mastodon_api/websocket_handler.ex

@@ -104,7 +104,7 @@ def handle_info(:ping, state) do
   end
 
   def handle_info(:close, state) do
-    {:stop, {:closed, 'connection closed by server'}, state}
+    {:stop, {:closed, ~c"connection closed by server"}, state}
   end
 
   def handle_info(msg, state) do

lib/pleroma/web/plugs/o_auth_scopes_plug.ex

@@ -34,7 +34,9 @@ def perform(%Plug.Conn{assigns: assigns} = conn, %{scopes: scopes} = options) do
         permissions = Enum.join(missing_scopes, " #{op} ")
 
         error_message =
-          dgettext("errors", "Insufficient permissions: %{permissions}.", permissions: permissions)
+          dgettext("errors", "Insufficient permissions: %{permissions}.",
+            permissions: permissions
+          )
 
         conn
         |> put_resp_content_type("application/json")

lib/pleroma/web/xml.ex

@@ -9,7 +9,7 @@ def string_from_xpath(_, :error), do: nil
 
   def string_from_xpath(xpath, doc) do
     try do
-      {:xmlObj, :string, res} = :xmerl_xpath.string('string(#{xpath})', doc)
+      {:xmlObj, :string, res} = :xmerl_xpath.string(~c"string(#{xpath})", doc)
 
       res =
         res

priv/repo/migrations/20180516154905_create_user_trigram_index.exs

@@ -7,7 +7,10 @@ defmodule Pleroma.Repo.Migrations.CreateUserTrigramIndex do
 
   def change do
     create_if_not_exists(
-      index(:users, ["(nickname || name) gist_trgm_ops"], name: :users_trigram_index, using: :gist)
+      index(:users, ["(nickname || name) gist_trgm_ops"],
+        name: :users_trigram_index,
+        using: :gist
+      )
     )
   end
 end

priv/repo/migrations/20190118074940_fix_user_trigram_index.exs

@@ -20,7 +20,10 @@ def down do
     drop_if_exists(index(:users, [], name: :users_trigram_index))
 
     create_if_not_exists(
-      index(:users, ["(nickname || name) gist_trgm_ops"], name: :users_trigram_index, using: :gist)
+      index(:users, ["(nickname || name) gist_trgm_ops"],
+        name: :users_trigram_index,
+        using: :gist
+      )
     )
   end
 end

priv/repo/migrations/20190603173419_add_tag_index_to_objects.exs

@@ -7,7 +7,10 @@ defmodule Pleroma.Repo.Migrations.AddTagIndexToObjects do
 
   def change do
     drop_if_exists(
-      index(:activities, ["(data #> '{\"object\",\"tag\"}')"], using: :gin, name: :activities_tags)
+      index(:activities, ["(data #> '{\"object\",\"tag\"}')"],
+        using: :gin,
+        name: :activities_tags
+      )
     )
 
     create_if_not_exists(index(:objects, ["(data->'tag')"], using: :gin, name: :objects_tags))

priv/repo/migrations/20200919182636_remoteip_plug_rename.exs

@@ -9,7 +9,9 @@ defmodule Pleroma.Repo.Migrations.RemoteipPlugRename do
 
   def up do
     config =
-      from(c in Pleroma.ConfigDB, where: c.group == ^:pleroma and c.key == ^Pleroma.Plugs.RemoteIp)
+      from(c in Pleroma.ConfigDB,
+        where: c.group == ^:pleroma and c.key == ^Pleroma.Plugs.RemoteIp
+      )
       |> Pleroma.Repo.one()
 
     if config do

test/pleroma/config_db_test.exs

@@ -312,7 +312,7 @@ test "proxy tuple with localhost" do
     test "proxy tuple with domain" do
       assert ConfigDB.to_elixir_types(%{
                "tuple" => [":proxy_url", %{"tuple" => [":socks5", "domain.com", 1234]}]
-             }) == {:proxy_url, {:socks5, 'domain.com', 1234}}
+             }) == {:proxy_url, {:socks5, ~c"domain.com", 1234}}
     end
 
     test "proxy tuple with ip" do

test/pleroma/http/adapter_helper/gun_test.exs

@@ -55,23 +55,23 @@ test "parses string proxy host & port" do
 
       uri = URI.parse("https://some-domain.com")
       opts = Gun.options([receive_conn: false], uri)
-      assert opts[:proxy] == {'localhost', 8123}
+      assert opts[:proxy] == {~c"localhost", 8123}
     end
 
     test "parses tuple proxy scheme host and port" do
-      clear_config([:http, :proxy_url], {:socks, 'localhost', 1234})
+      clear_config([:http, :proxy_url], {:socks, ~c"localhost", 1234})
 
       uri = URI.parse("https://some-domain.com")
       opts = Gun.options([receive_conn: false], uri)
-      assert opts[:proxy] == {:socks, 'localhost', 1234}
+      assert opts[:proxy] == {:socks, ~c"localhost", 1234}
     end
 
     test "passed opts have more weight than defaults" do
-      clear_config([:http, :proxy_url], {:socks5, 'localhost', 1234})
+      clear_config([:http, :proxy_url], {:socks5, ~c"localhost", 1234})
       uri = URI.parse("https://some-domain.com")
-      opts = Gun.options([receive_conn: false, proxy: {'example.com', 4321}], uri)
+      opts = Gun.options([receive_conn: false, proxy: {~c"example.com", 4321}], uri)
 
-      assert opts[:proxy] == {'example.com', 4321}
+      assert opts[:proxy] == {~c"example.com", 4321}
     end
   end
 end

test/pleroma/http/adapter_helper_test.exs

@@ -17,12 +17,12 @@ test "with string" do
     end
 
     test "localhost with port" do
-      assert AdapterHelper.format_proxy("localhost:8123") == {'localhost', 8123}
+      assert AdapterHelper.format_proxy("localhost:8123") == {~c"localhost", 8123}
     end
 
     test "tuple" do
       assert AdapterHelper.format_proxy({:socks4, :localhost, 9050}) ==
-               {:socks4, 'localhost', 9050}
+               {:socks4, ~c"localhost", 9050}
     end
   end
 end

test/pleroma/job_queue_monitor_test.exs

@@ -28,13 +28,13 @@ defmodule Pleroma.JobQueueMonitorTest do
               queue: "background",
               stack: [
                 {Pleroma.Workers.BackgroundWorker, :perform, 2,
-                 [file: 'lib/pleroma/workers/background_worker.ex', line: 31]},
+                 [file: ~c"lib/pleroma/workers/background_worker.ex", line: 31]},
                 {Oban.Queue.Executor, :safe_call, 1,
-                 [file: 'lib/oban/queue/executor.ex', line: 42]},
-                {:timer, :tc, 3, [file: 'timer.erl', line: 197]},
-                {Oban.Queue.Executor, :call, 2, [file: 'lib/oban/queue/executor.ex', line: 23]},
-                {Task.Supervised, :invoke_mfa, 2, [file: 'lib/task/supervised.ex', line: 90]},
-                {:proc_lib, :init_p_do_apply, 3, [file: 'proc_lib.erl', line: 249]}
+                 [file: ~c"lib/oban/queue/executor.ex", line: 42]},
+                {:timer, :tc, 3, [file: ~c"timer.erl", line: 197]},
+                {Oban.Queue.Executor, :call, 2, [file: ~c"lib/oban/queue/executor.ex", line: 23]},
+                {Task.Supervised, :invoke_mfa, 2, [file: ~c"lib/task/supervised.ex", line: 90]},
+                {:proc_lib, :init_p_do_apply, 3, [file: ~c"proc_lib.erl", line: 249]}
               ],
               worker: "Pleroma.Workers.BackgroundWorker"
             }}

test/pleroma/notification_test.exs

@@ -339,7 +339,10 @@ test "it creates `follow_request` notification for pending Follow activity" do
         |> Repo.preload(:activity)
 
       assert %{type: "follow"} =
-               NotificationView.render("show.json", notification: notification, for: followed_user)
+               NotificationView.render("show.json",
+                 notification: notification,
+                 for: followed_user
+               )
     end
 
     test "it doesn't create a notification for follow-unfollow-follow chains" do

test/pleroma/user/backup_test.exs

@@ -188,7 +188,7 @@ test "it creates a zip archive with user data" do
     assert {:ok, backup} = user |> Backup.new() |> Repo.insert()
     assert {:ok, path} = Backup.export(backup, self())
     assert {:ok, zipfile} = :zip.zip_open(String.to_charlist(path), [:memory])
-    assert {:ok, {'actor.json', json}} = :zip.zip_get('actor.json', zipfile)
+    assert {:ok, {~c"actor.json", json}} = :zip.zip_get(~c"actor.json", zipfile)
 
     assert %{
              "@context" => [
@@ -213,7 +213,7 @@ test "it creates a zip archive with user data" do
              "url" => "http://cofe.io/users/cofe"
            } = Jason.decode!(json)
 
-    assert {:ok, {'outbox.json', json}} = :zip.zip_get('outbox.json', zipfile)
+    assert {:ok, {~c"outbox.json", json}} = :zip.zip_get(~c"outbox.json", zipfile)
 
     assert %{
              "@context" => "https://www.w3.org/ns/activitystreams",
@@ -244,7 +244,7 @@ test "it creates a zip archive with user data" do
              "type" => "OrderedCollection"
            } = Jason.decode!(json)
 
-    assert {:ok, {'likes.json', json}} = :zip.zip_get('likes.json', zipfile)
+    assert {:ok, {~c"likes.json", json}} = :zip.zip_get(~c"likes.json", zipfile)
 
     assert %{
              "@context" => "https://www.w3.org/ns/activitystreams",
@@ -254,7 +254,7 @@ test "it creates a zip archive with user data" do
              "type" => "OrderedCollection"
            } = Jason.decode!(json)
 
-    assert {:ok, {'bookmarks.json', json}} = :zip.zip_get('bookmarks.json', zipfile)
+    assert {:ok, {~c"bookmarks.json", json}} = :zip.zip_get(~c"bookmarks.json", zipfile)
 
     assert %{
              "@context" => "https://www.w3.org/ns/activitystreams",
@@ -264,7 +264,7 @@ test "it creates a zip archive with user data" do
              "type" => "OrderedCollection"
            } = Jason.decode!(json)
 
-    assert {:ok, {'following.json', json}} = :zip.zip_get('following.json', zipfile)
+    assert {:ok, {~c"following.json", json}} = :zip.zip_get(~c"following.json", zipfile)
 
     assert %{
              "@context" => "https://www.w3.org/ns/activitystreams",

test/pleroma/web/feed/tag_controller_test.exs

@@ -55,11 +55,11 @@ test "gets a feed (ATOM)", %{conn: conn} do
 
     xml = parse(response)
 
-    assert xpath(xml, ~x"//feed/title/text()") == '#pleromaart'
+    assert xpath(xml, ~x"//feed/title/text()") == ~c"#pleromaart"
 
     assert xpath(xml, ~x"//feed/entry/title/text()"l) == [
-             '42 This is :moominmamm...',
-             'yeah #PleromaArt'
+             ~c"42 This is :moominmamm...",
+             ~c"yeah #PleromaArt"
            ]
 
     assert xpath(xml, ~x"//feed/entry/author/name/text()"ls) == [user.nickname, user.nickname]
@@ -73,10 +73,10 @@ test "gets a feed (ATOM)", %{conn: conn} do
     resp = response(conn, 200)
     xml = parse(resp)
 
-    assert xpath(xml, ~x"//feed/title/text()") == '#pleromaart'
+    assert xpath(xml, ~x"//feed/title/text()") == ~c"#pleromaart"
 
     assert xpath(xml, ~x"//feed/entry/title/text()"l) == [
-             'yeah #PleromaArt'
+             ~c"yeah #PleromaArt"
            ]
   end
 
@@ -120,20 +120,20 @@ test "gets a feed (RSS)", %{conn: conn} do
       |> response(200)
 
     xml = parse(response)
-    assert xpath(xml, ~x"//channel/title/text()") == '#pleromaart'
+    assert xpath(xml, ~x"//channel/title/text()") == ~c"#pleromaart"
 
     assert xpath(xml, ~x"//channel/description/text()"s) ==
              "These are public toots tagged with #pleromaart. You can interact with them if you have an account anywhere in the fediverse."
 
     assert xpath(xml, ~x"//channel/link/text()") ==
-             '#{Pleroma.Web.Endpoint.url()}/tags/pleromaart.rss'
+             ~c"#{Pleroma.Web.Endpoint.url()}/tags/pleromaart.rss"
 
     assert xpath(xml, ~x"//channel/webfeeds:logo/text()") ==
-             '#{Pleroma.Web.Endpoint.url()}/static/logo.svg'
+             ~c"#{Pleroma.Web.Endpoint.url()}/static/logo.svg"
 
     assert xpath(xml, ~x"//channel/item/title/text()"l) == [
-             '42 This is :moominmamm...',
-             'yeah #PleromaArt'
+             ~c"42 This is :moominmamm...",
+             ~c"yeah #PleromaArt"
            ]
 
     assert xpath(xml, ~x"//channel/item/pubDate/text()"sl) == [
@@ -160,7 +160,7 @@ test "gets a feed (RSS)", %{conn: conn} do
       |> response(200)
 
     xml = parse(response)
-    assert xpath(xml, ~x"//channel/title/text()") == '#pleromaart'
+    assert xpath(xml, ~x"//channel/title/text()") == ~c"#pleromaart"
 
     assert xpath(xml, ~x"//channel/description/text()"s) ==
              "These are public toots tagged with #pleromaart. You can interact with them if you have an account anywhere in the fediverse."
@@ -174,10 +174,10 @@ test "gets a feed (RSS)", %{conn: conn} do
     resp = response(conn, 200)
     xml = parse(resp)
 
-    assert xpath(xml, ~x"//channel/title/text()") == '#pleromaart'
+    assert xpath(xml, ~x"//channel/title/text()") == ~c"#pleromaart"
 
     assert xpath(xml, ~x"//channel/item/title/text()"l) == [
-             'yeah #PleromaArt'
+             ~c"yeah #PleromaArt"
            ]
   end
 

test/pleroma/web/feed/user_controller_test.exs

@@ -88,7 +88,7 @@ test "gets an atom feed", %{conn: conn, user: user, object: object, max_id: max_
         |> SweetXml.parse()
         |> SweetXml.xpath(~x"//entry/title/text()"l)
 
-      assert activity_titles == ['Won\'t, didn\'...', '2hu', '2hu & as']
+      assert activity_titles == [~c"Won't, didn'...", ~c"2hu", ~c"2hu & as"]
       assert resp =~ FeedView.escape(object.data["content"])
       assert resp =~ FeedView.escape(object.data["summary"])
       assert resp =~ FeedView.escape(object.data["context"])
@@ -104,7 +104,7 @@ test "gets an atom feed", %{conn: conn, user: user, object: object, max_id: max_
         |> SweetXml.parse()
         |> SweetXml.xpath(~x"//entry/title/text()"l)
 
-      assert activity_titles == ['2hu & as']
+      assert activity_titles == [~c"2hu & as"]
     end
 
     test "gets a rss feed", %{conn: conn, user: user, object: object, max_id: max_id} do
@@ -119,7 +119,7 @@ test "gets a rss feed", %{conn: conn, user: user, object: object, max_id: max_id
         |> SweetXml.parse()
         |> SweetXml.xpath(~x"//item/title/text()"l)
 
-      assert activity_titles == ['Won\'t, didn\'...', '2hu', '2hu & as']
+      assert activity_titles == [~c"Won't, didn'...", ~c"2hu", ~c"2hu & as"]
       assert resp =~ FeedView.escape(object.data["content"])
       assert resp =~ FeedView.escape(object.data["summary"])
       assert resp =~ FeedView.escape(object.data["context"])
@@ -135,7 +135,7 @@ test "gets a rss feed", %{conn: conn, user: user, object: object, max_id: max_id
         |> SweetXml.parse()
         |> SweetXml.xpath(~x"//item/title/text()"l)
 
-      assert activity_titles == ['2hu & as']
+      assert activity_titles == [~c"2hu & as"]
     end
 
     test "returns 404 for a missing feed", %{conn: conn} do
@@ -167,7 +167,7 @@ test "returns feed with public and unlisted activities", %{conn: conn} do
         |> SweetXml.xpath(~x"//entry/title/text()"l)
         |> Enum.sort()
 
-      assert activity_titles == ['public', 'unlisted']
+      assert activity_titles == [~c"public", ~c"unlisted"]
     end
 
     test "returns 404 when the user is remote", %{conn: conn} do
@@ -208,7 +208,7 @@ test "does not mangle HTML entities midway", %{
         |> SweetXml.parse()
         |> SweetXml.xpath(~x"//entry/title/text()"l)
 
-      assert activity_titles == ['Won\'t, didn\'...', '2hu', '2hu & as']
+      assert activity_titles == [~c"Won't, didn'...", ~c"2hu", ~c"2hu & as"]
       assert resp =~ FeedView.escape(object.data["content"])
       assert resp =~ FeedView.escape(object.data["summary"])
       assert resp =~ FeedView.escape(object.data["context"])

test/pleroma/web/mastodon_api/views/status_view_test.exs

@@ -467,7 +467,9 @@ test "quoted private post" do
 
     # Create a public post quoting the private post
     quote_private =
-      insert(:note_activity, note: insert(:note, data: %{"quoteUrl" => private_object.data["id"]}))
+      insert(:note_activity,
+        note: insert(:note, data: %{"quoteUrl" => private_object.data["id"]})
+      )
 
     status = StatusView.render("show.json", %{activity: quote_private})
 

test/pleroma/web/o_auth/ldap_authorization_test.exs

@@ -71,7 +71,7 @@ test "creates a new user after successful LDAP authorization" do
          equalityMatch: fn _type, _value -> :ok end,
          wholeSubtree: fn -> :ok end,
          search: fn _connection, _options ->
-           {:ok, {:eldap_search_result, [{:eldap_entry, '', []}], []}}
+           {:ok, {:eldap_search_result, [{:eldap_entry, ~c"", []}], []}}
          end,
          close: fn _connection ->
            send(self(), :close_connection)

test/pleroma/web/pleroma_api/controllers/emoji_pack_controller_test.exs

@@ -159,8 +159,8 @@ test "download shared pack", %{conn: conn} do
 
       {:ok, arch} = :zip.unzip(resp, [:memory])
 
-      assert Enum.find(arch, fn {n, _} -> n == 'pack.json' end)
-      assert Enum.find(arch, fn {n, _} -> n == 'blank.png' end)
+      assert Enum.find(arch, fn {n, _} -> n == ~c"pack.json" end)
+      assert Enum.find(arch, fn {n, _} -> n == ~c"blank.png" end)
     end
 
     test "non existing pack", %{conn: conn} do
@@ -454,7 +454,7 @@ test "when the fallback source doesn't have all the files", ctx do
           method: :get,
           url: "https://nonshared-pack"
         } ->
-          {:ok, {'empty.zip', empty_arch}} = :zip.zip('empty.zip', [], [:memory])
+          {:ok, {~c"empty.zip", empty_arch}} = :zip.zip(~c"empty.zip", [], [:memory])
           text(empty_arch)
       end)
 

test/pleroma/web/push/impl_test.exs

@@ -351,7 +351,10 @@ test "returns regular content when hiding contents option disabled" do
       user = insert(:user, nickname: "Bob")
 
       user2 =
-        insert(:user, nickname: "Rob", notification_settings: %{hide_notification_contents: false})
+        insert(:user,
+          nickname: "Rob",
+          notification_settings: %{hide_notification_contents: false}
+        )
 
       {:ok, activity} =
         CommonAPI.post(user, %{