Pretty error printing

CMakeLists.txt

@@ -413,7 +413,7 @@ if(USE_BUNDLED_MTXCLIENT)
 	FetchContent_Declare(
 		MatrixClient
 		GIT_REPOSITORY https://github.com/Nheko-Reborn/mtxclient.git
-		GIT_TAG        v0.6.0
+		GIT_TAG        ffc1d3e13a507fa501966b2d7e9d4eda881f6bf4
 		)
 	set(BUILD_LIB_EXAMPLES OFF CACHE INTERNAL "")
 	set(BUILD_LIB_TESTS OFF CACHE INTERNAL "")
@@ -710,7 +710,7 @@ if(USE_BUNDLED_COEURL)
 	FetchContent_Declare(
 		coeurl
 		GIT_REPOSITORY https://nheko.im/Nheko-Reborn/coeurl.git
-		GIT_TAG        v0.1.0
+		GIT_TAG        abafd60d7e9f5cce76c9abad3b2b3dc1382e5349
 		)
 	FetchContent_MakeAvailable(coeurl)
 	target_link_libraries(nheko PUBLIC coeurl::coeurl)

io.github.NhekoReborn.Nheko.yaml

@@ -175,8 +175,7 @@ modules:
       - -Ddefault_library=static
     name: coeurl
     sources:
-      - commit: a08f619adaa1ccd34eb6315d6578eddae0d1cc9b
+      - commit: abafd60d7e9f5cce76c9abad3b2b3dc1382e5349
-        tag: v0.1.0
         type: git
         url: https://nheko.im/nheko-reborn/coeurl.git
   - config-opts:
@@ -187,8 +186,7 @@ modules:
     buildsystem: cmake-ninja
     name: mtxclient
     sources:
-      - commit: eecc4e93f2137c658014f17cefd62ad569063769
+      - commit: ffc1d3e13a507fa501966b2d7e9d4eda881f6bf4
-        tag: v0.6.0
         type: git
         url: https://github.com/Nheko-Reborn/mtxclient.git
   - config-opts:

src/ChatPage.cpp

@@ -662,8 +662,6 @@ ChatPage::trySync()
           if (err) {
               const auto error      = QString::fromStdString(err->matrix_error.error);
               const auto msg        = tr("Please try to login again: %1").arg(error);
-              const auto err_code   = mtx::errors::to_string(err->matrix_error.errcode);
-              const int status_code = static_cast<int>(err->status_code);
 
               if ((http::is_logged_in() &&
                    (err->matrix_error.errcode == mtx::errors::ErrorCode::M_UNKNOWN_TOKEN ||
@@ -673,11 +671,7 @@ ChatPage::trySync()
                   return;
               }
 
-              nhlog::net()->error("sync error: {} {} {} {}",
+              nhlog::net()->error("sync error: {}", *err);
-                                  err->parse_error,
-                                  status_code,
-                                  err->error_code,
-                                  err_code);
               emit tryDelayedSyncCb();
               return;
           }

src/MatrixClient.h

@@ -6,6 +6,10 @@
 
 #include <mtxclient/http/client.hpp>
 
+#include <curl/curl.h>
+
+#include "Logging.h"
+
 namespace http {
 mtx::http::Client *
 client();
@@ -17,3 +21,115 @@ is_logged_in();
 void
 init();
 }
+
+template<>
+struct fmt::formatter<mtx::http::ClientError>
+{
+    // Presentation format: 'f' - fixed, 'e' - exponential.
+    bool print_network_error = false;
+    bool print_http_error    = false;
+    bool print_parser_error  = false;
+    bool print_matrix_error  = false;
+
+    // Parses format specifications of the form ['f' | 'e'].
+    constexpr auto parse(format_parse_context &ctx) -> decltype(ctx.begin())
+    {
+        // [ctx.begin(), ctx.end()) is a character range that contains a part of
+        // the format string starting from the format specifications to be parsed,
+        // e.g. in
+        //
+        //   fmt::format("{:f} - point of interest", point{1, 2});
+        //
+        // the range will contain "f} - point of interest". The formatter should
+        // parse specifiers until '}' or the end of the range. In this example
+        // the formatter should parse the 'f' specifier and return an iterator
+        // pointing to '}'.
+
+        // Parse the presentation format and store it in the formatter:
+        auto it = ctx.begin(), end = ctx.end();
+
+        while (it != end && *it != '}') {
+            auto tmp = *it++;
+
+            switch (tmp) {
+            case 'n':
+                print_matrix_error = true;
+                break;
+            case 'h':
+                print_matrix_error = true;
+                break;
+            case 'p':
+                print_matrix_error = true;
+                break;
+            case 'm':
+                print_matrix_error = true;
+                break;
+            default:
+                throw format_error("invalid format specifier for mtx error");
+            }
+        }
+
+        // Check if reached the end of the range:
+        if (it != end && *it != '}')
+            throw format_error("invalid format");
+
+        // Return an iterator past the end of the parsed range:
+        return it;
+    }
+
+    // Formats the point p using the parsed format specification (presentation)
+    // stored in this formatter.
+    template<typename FormatContext>
+    auto format(const mtx::http::ClientError &e, FormatContext &ctx) -> decltype(ctx.out())
+    {
+        // ctx.out() is an output iterator to write to.
+        bool prepend_comma = false;
+        format_to(ctx.out(), "(");
+        if (print_network_error || e.error_code) {
+            format_to(ctx.out(), "connection: {}", e.error_code_string());
+            prepend_comma = true;
+        }
+
+        if (print_http_error ||
+            (e.status_code != 0 && (e.status_code < 200 || e.status_code >= 300))) {
+            if (prepend_comma)
+                format_to(ctx.out(), ", ");
+            format_to(ctx.out(), "http: {}", e.status_code);
+            prepend_comma = true;
+        }
+
+        if (print_parser_error || !e.parse_error.empty()) {
+            if (prepend_comma)
+                format_to(ctx.out(), ", ");
+            format_to(ctx.out(), "parser: {}", e.parse_error);
+            prepend_comma = true;
+        }
+
+        if (print_parser_error ||
+            (e.matrix_error.errcode != mtx::errors::ErrorCode::M_UNRECOGNIZED &&
+             !e.matrix_error.error.empty())) {
+            if (prepend_comma)
+                format_to(ctx.out(), ", ");
+            format_to(ctx.out(),
+                      "matrix: {}:'{}'",
+                      to_string(e.matrix_error.errcode),
+                      e.matrix_error.error);
+        }
+
+        return format_to(ctx.out(), ")");
+    }
+};
+
+template<>
+struct fmt::formatter<std::optional<mtx::http::ClientError>> : formatter<mtx::http::ClientError>
+{
+    // parse is inherited from formatter<string_view>.
+    template<typename FormatContext>
+    auto format(std::optional<mtx::http::ClientError> c, FormatContext &ctx)
+    {
+        if (!c)
+            return format_to(ctx.out(), "(no error)");
+        else
+            return formatter<mtx::http::ClientError>::format(*c, ctx);
+    }
+};