style: clang-tidy auto fixes (#2958)

Co-authored-by: godexsoft <385326+godexsoft@users.noreply.github.com>

Author: github-actions[bot]

src/app/CliArgs.cpp

@@ -104,10 +104,11 @@ CliArgs::parse(int argc, char const* argv[])
 
     if (parsed.contains("migrate")) {
         auto const opt = parsed["migrate"].as<std::string>();
-        if (opt == "status")
+        if (opt == "status") {
             return Action{Action::Migrate{
                 .configPath = std::move(configPath), .subCmd = MigrateSubCmd::status()
             }};
+        }
         return Action{Action::Migrate{
             .configPath = std::move(configPath), .subCmd = MigrateSubCmd::migration(opt)
         }};

src/data/cassandra/Handle.cpp

@@ -85,10 +85,11 @@ Handle::disconnect() const
 Handle::FutureType
 Handle::asyncReconnect(std::string_view keyspace) const
 {
-    if (auto rc = asyncDisconnect().await(); not rc)  // sync
+    if (auto rc = asyncDisconnect().await(); not rc) {  // sync
         throw std::logic_error(
             "Reconnect to keyspace '" + std::string{keyspace} + "' failed: " + rc.error()
         );
+    }
     return asyncConnect(keyspace);
 }
 

src/data/cassandra/impl/Statement.hpp

@@ -96,10 +96,11 @@ class Statement : public ManagedObject<CassStatement> {
     {
         using std::to_string;
         auto throwErrorIfNeeded = [idx](CassError rc, std::string_view label) {
-            if (rc != CASS_OK)
+            if (rc != CASS_OK) {
                 throw std::logic_error(
                     fmt::format("[{}] at idx {}: {}", label, idx, cass_error_desc(rc))
                 );
+            }
         };
 
         auto bindBytes = [this, idx](auto const* data, size_t size) {

src/etl/LoadBalancer.cpp

@@ -203,10 +203,11 @@ LoadBalancer::LoadBalancer(
         LOG(log_.info()) << "Added etl source - " << sources_.back()->toString();
     }
 
-    if (!etlState_)
+    if (!etlState_) {
         checkOnETLFailure(
             "Failed to fetch ETL state from any source. Please check the configuration and network"
         );
+    }
 
     if (sources_.empty())
         checkOnETLFailure("No ETL sources configured. Please check the configuration");

src/etl/NFTHelpers.cpp

@@ -138,8 +138,7 @@ getNFTokenMintData(ripple::TxMeta const& txMeta, ripple::STTx const& sttx)
     // Find the first NFT ID that doesn't match.  We're looking for an
     // added NFT, so the one we want will be the mismatch in finalIDs.
     // NOLINTNEXTLINE(modernize-use-ranges)
-    auto const diff =
-        std::mismatch(finalIDs.begin(), finalIDs.end(), prevIDs.begin(), prevIDs.end());
+    auto const diff = std::ranges::mismatch(finalIDs, prevIDs);
 
     // There should always be a difference so the returned finalIDs
     // iterator should never be end().  But better safe than sorry.
@@ -402,10 +401,11 @@ getNFTDataFromObj(std::uint32_t const seq, std::string const& key, std::string c
     auto const owner = ripple::AccountID::fromVoid(key.data());
     std::vector<NFTsData> nfts;
 
-    for (ripple::STObject const& node : sle.getFieldArray(ripple::sfNFTokens))
+    for (ripple::STObject const& node : sle.getFieldArray(ripple::sfNFTokens)) {
         nfts.emplace_back(
             node.getFieldH256(ripple::sfNFTokenID), seq, owner, node.getFieldVL(ripple::sfURI)
         );
+    }
 
     return nfts;
 }

src/etl/impl/Registry.hpp

@@ -173,10 +173,11 @@ class Registry : public RegistryInterface {
         // send entire vector path
         {
             auto const expand = [&](auto&& p) {
-                if constexpr (requires { p.onInitialObjects(seq, data, lastKey); })
+                if constexpr (requires { p.onInitialObjects(seq, data, lastKey); }) {
                     executeIfAllowed(p, [seq, &data, &lastKey](auto& p) {
                         p.onInitialObjects(seq, data, lastKey);
                     });
+                }
             };
 
             std::apply([&expand](auto&&... xs) { (expand(xs), ...); }, store_);
@@ -212,10 +213,11 @@ class Registry : public RegistryInterface {
         {
             auto const expand = [&]<typename P>(P&& p, model::Transaction const& tx) {
                 if constexpr (requires { p.onInitialTransaction(data.seq, tx); }) {
-                    if (std::decay_t<P>::spec::wants(tx.type))
+                    if (std::decay_t<P>::spec::wants(tx.type)) {
                         executeIfAllowed(p, [&data, &tx](auto& p) {
                             p.onInitialTransaction(data.seq, tx);
                         });
+                    }
                 }
             };
 

src/rpc/CredentialHelpers.cpp

@@ -153,10 +153,11 @@ fetchCredentialArray(
         if (credentials::checkExpired(sleCred, info))
             return Error{Status{RippledError::rpcBAD_CREDENTIALS, "credentials are expired"}};
 
-        if (sleCred.getAccountID(ripple::sfSubject) != srcAcc)
+        if (sleCred.getAccountID(ripple::sfSubject) != srcAcc) {
             return Error{Status{
                 RippledError::rpcBAD_CREDENTIALS, "credentials don't belong to the root account"
             }};
+        }
 
         auto credential = ripple::STObject::makeInnerObject(ripple::sfCredential);
         credential.setAccountID(ripple::sfIssuer, sleCred.getAccountID(ripple::sfIssuer));

src/rpc/Errors.cpp

@@ -223,10 +223,11 @@ makeError(Status const& status)
     auto res = visit(
         util::OverloadSet{
             [&status, &wrapOptional](RippledError err) {
-                if (err == ripple::rpcUNKNOWN)
+                if (err == ripple::rpcUNKNOWN) {
                     return boost::json::object{
                         {"error", status.message}, {"type", "response"}, {"status", "error"}
                     };
+                }
 
                 return makeError(err, wrapOptional(status.error), wrapOptional(status.message));
             },

src/rpc/Factories.cpp

@@ -62,10 +62,11 @@ makeWsContext(
         commandValue = request.at("command");
     }
 
-    if (!commandValue.is_string())
+    if (!commandValue.is_string()) {
         return Error{
             {ClioError::RpcCommandIsMissing, "Method/Command is not specified or is not a string."}
         };
+    }
 
     auto const apiVersion = apiVersionParser.get().parse(request);
     if (!apiVersion)
@@ -99,11 +100,12 @@ makeHttpContext(
 
     auto const command = boost::json::value_to<std::string>(request.at("method"));
 
-    if (command == "subscribe" || command == "unsubscribe")
+    if (command == "subscribe" || command == "unsubscribe") {
         return Error{
             {RippledError::rpcBAD_SYNTAX,
              "Subscribe and unsubscribe are only allowed for websocket."}
         };
+    }
 
     if (!request.at("params").is_array())
         return Error{{ClioError::RpcParamsUnparsable, "Missing params array."}};

src/rpc/RPCHelpers.cpp

@@ -694,10 +694,11 @@ traverseOwnedNodes(
         auto const [nextNFTPage, nftsCount] = cursorMaybe.value();
 
         // if limit reach , we return the next page and max as marker
-        if (nftsCount >= limit)
+        if (nftsCount >= limit) {
             return AccountCursor{
                 .index = nextNFTPage, .hint = std::numeric_limits<uint32_t>::max()
             };
+        }
 
         // adjust limit ,continue traversing owned nodes
         limit -= nftsCount;
@@ -772,10 +773,11 @@ traverseOwnedNodes(
         for (;;) {
             auto const ownerDir = backend.fetchLedgerObject(currentIndex.key, sequence, yield);
 
-            if (!ownerDir)
+            if (!ownerDir) {
                 return std::unexpected{
                     Status(ripple::rpcINVALID_PARAMS, "Owner directory not found.")
                 };
+            }
 
             ripple::SerialIter ownedDirIt{ownerDir->data(), ownerDir->size()};
             ripple::SLE const ownedDirSle{ownedDirIt, currentIndex.key};
@@ -1428,25 +1430,29 @@ parseBook(
 std::expected<ripple::Book, Status>
 parseBook(boost::json::object const& request)
 {
-    if (!request.contains("taker_pays"))
+    if (!request.contains("taker_pays")) {
         return std::unexpected{
             Status{RippledError::rpcINVALID_PARAMS, "Missing field 'taker_pays'"}
         };
+    }
 
-    if (!request.contains("taker_gets"))
+    if (!request.contains("taker_gets")) {
         return std::unexpected{
             Status{RippledError::rpcINVALID_PARAMS, "Missing field 'taker_gets'"}
         };
+    }
 
-    if (!request.at("taker_pays").is_object())
+    if (!request.at("taker_pays").is_object()) {
         return std::unexpected{
             Status{RippledError::rpcINVALID_PARAMS, "Field 'taker_pays' is not an object"}
         };
+    }
 
-    if (!request.at("taker_gets").is_object())
+    if (!request.at("taker_gets").is_object()) {
         return std::unexpected{
             Status{RippledError::rpcINVALID_PARAMS, "Field 'taker_gets' is not an object"}
         };
+    }
 
     auto takerPays = request.at("taker_pays").as_object();
     if (!takerPays.contains("currency"))
@@ -1482,10 +1488,11 @@ parseBook(boost::json::object const& request)
 
     ripple::AccountID payIssuer;
     if (takerPays.contains("issuer")) {
-        if (!takerPays.at("issuer").is_string())
+        if (!takerPays.at("issuer").is_string()) {
             return std::unexpected{
                 Status{RippledError::rpcINVALID_PARAMS, "takerPaysIssuerNotString"}
             };
+        }
 
         if (!ripple::to_issuer(
                 payIssuer, boost::json::value_to<std::string>(takerPays.at("issuer"))
@@ -1512,18 +1519,20 @@ parseBook(boost::json::object const& request)
         }};
     }
 
-    if ((!isXRP(payCurrency)) && (!takerPays.contains("issuer")))
+    if ((!isXRP(payCurrency)) && (!takerPays.contains("issuer"))) {
         return std::unexpected{
             Status{RippledError::rpcSRC_ISR_MALFORMED, "Missing non-XRP issuer."}
         };
+    }
 
     ripple::AccountID getIssuer;
 
     if (takerGets.contains("issuer")) {
-        if (!takerGets["issuer"].is_string())
+        if (!takerGets["issuer"].is_string()) {
             return std::unexpected{
                 Status{RippledError::rpcINVALID_PARAMS, "taker_gets.issuer should be string"}
             };
+        }
 
         if (!ripple::to_issuer(
                 getIssuer, boost::json::value_to<std::string>(takerGets.at("issuer"))