Add getPath and setPath methods to the Uri class, fix a bug in joinToString

CHANGES.md

@@ -1,5 +1,15 @@
 # Change Log
 
+### ? - ?
+
+##### Additions :tada:
+
+- Added `Uri::getPath` and `Uri::setPath`.
+
+##### Fixes :wrench:
+
+- Fixed a bug in `joinToString` when given a collection containing empty strings.
+
 ### v0.34.0 - 2024-04-01
 
 ##### Breaking Changes :mega:

CesiumUtility/include/CesiumUtility/Uri.h

@@ -24,5 +24,25 @@ class Uri final {
       const std::function<SubstitutionCallbackSignature>& substitutionCallback);
 
   static std::string escape(const std::string& s);
+
+  /**
+   * @brief Gets the path portion of the URI.
+   *
+   * @param uri The URI from which to get the path.
+   * @return The path, or empty string if the URI could not be parsed.
+   */
+  static std::string getPath(const std::string& uri);
+
+  /**
+   * @brief Sets the path portion of a URI to a new value. The other portions of
+   * the URI are left unmodified.
+   *
+   * @param uri The URI for which to set the path.
+   * @param The new path portion of the URI.
+   * @returns The new URI after setting the path. If the original URI cannot be
+   * parsed, it is returned unmodified.
+   */
+  static std::string
+  setPath(const std::string& uri, const std::string& newPath);
 };
 } // namespace CesiumUtility

CesiumUtility/include/CesiumUtility/joinToString.h

@@ -17,16 +17,17 @@ namespace CesiumUtility {
 template <class TIterator>
 std::string
 joinToString(TIterator begin, TIterator end, const std::string& separator) {
+  if (begin == end)
+    return std::string();
+
+  std::string first = *begin;
+
   return std::accumulate(
-      begin,
+      ++begin,
       end,
-      std::string(),
+      std::move(first),
       [&separator](const std::string& acc, const std::string& element) {
-        if (!acc.empty()) {
-          return acc + separator + element;
-        } else {
-          return element;
-        }
+        return acc + separator + element;
       });
 }
 
@@ -41,16 +42,6 @@ joinToString(TIterator begin, TIterator end, const std::string& separator) {
  */
 template <class TCollection>
 std::string joinToString(TCollection collection, const std::string& separator) {
-  return std::accumulate(
-      collection.cbegin(),
-      collection.cend(),
-      std::string(),
-      [&separator](const std::string& acc, const std::string& element) {
-        if (!acc.empty()) {
-          return acc + separator + element;
-        } else {
-          return element;
-        }
-      });
+  return joinToString(collection.cbegin(), collection.cend(), separator);
 }
 } // namespace CesiumUtility

CesiumUtility/src/Uri.cpp

@@ -1,9 +1,13 @@
 #include "CesiumUtility/Uri.h"
 
+#include <CesiumUtility/joinToString.h>
+
 #include <uriparser/Uri.h>
 
+#include <cstdlib>
 #include <cstring>
 #include <stdexcept>
+#include <vector>
 
 namespace CesiumUtility {
 std::string Uri::resolve(
@@ -175,4 +179,104 @@ std::string Uri::escape(const std::string& s) {
   result.resize(size_t(pTerminator - result.data()));
   return result;
 }
+
+std::string Uri::getPath(const std::string& uri) {
+  UriUriA parsedUri;
+  if (uriParseSingleUriA(&parsedUri, uri.c_str(), nullptr) != URI_SUCCESS) {
+    // Could not parse the URI, so return an empty string.
+    return std::string();
+  }
+
+  // The initial string in this vector can be thought of as the "nothing" before
+  // the first slash in the path.
+  std::vector<std::string> parts{std::string()};
+
+  UriPathSegmentA* pCurrent = parsedUri.pathHead;
+  while (pCurrent != nullptr) {
+    parts.emplace_back(std::string(
+        pCurrent->text.first,
+        size_t(pCurrent->text.afterLast - pCurrent->text.first)));
+    pCurrent = pCurrent->next;
+  }
+
+  uriFreeUriMembersA(&parsedUri);
+
+  return joinToString(parts, "/");
+}
+
+std::string Uri::setPath(const std::string& uri, const std::string& newPath) {
+  UriUriA parsedUri;
+  if (uriParseSingleUriA(&parsedUri, uri.c_str(), nullptr) != URI_SUCCESS) {
+    // Could not parse the URI, so return an empty string.
+    return std::string();
+  }
+
+  // Free the existing path. Strangely, uriparser doesn't provide any simple way
+  // to do this.
+  UriPathSegmentA* pCurrent = parsedUri.pathHead;
+  while (pCurrent != nullptr) {
+    UriPathSegmentA* pNext = pCurrent->next;
+    free(pCurrent);
+    pCurrent = pNext;
+  }
+
+  parsedUri.pathHead = nullptr;
+  parsedUri.pathTail = nullptr;
+
+  // Set the new path.
+  if (!newPath.empty()) {
+    std::string::size_type startPos = 0;
+    do {
+      std::string::size_type nextSlashIndex = newPath.find('/', startPos);
+
+      // Skip the initial slash if there is one.
+      if (nextSlashIndex == 0) {
+        startPos = 1;
+        continue;
+      }
+
+      UriPathSegmentA* pSegment =
+          static_cast<UriPathSegmentA*>(malloc(sizeof(UriPathSegmentA)));
+      memset(pSegment, 0, sizeof(UriPathSegmentA));
+
+      if (parsedUri.pathHead == nullptr) {
+        parsedUri.pathHead = pSegment;
+        parsedUri.pathTail = pSegment;
+      } else {
+        parsedUri.pathTail->next = pSegment;
+        parsedUri.pathTail = parsedUri.pathTail->next;
+      }
+
+      pSegment->text.first = newPath.data() + startPos;
+
+      if (nextSlashIndex != std::string::npos) {
+        pSegment->text.afterLast = newPath.data() + nextSlashIndex;
+        startPos = nextSlashIndex + 1;
+      } else {
+        pSegment->text.afterLast = newPath.data() + newPath.size();
+        startPos = nextSlashIndex;
+      }
+    } while (startPos != std::string::npos);
+  }
+
+  int charsRequired;
+  if (uriToStringCharsRequiredA(&parsedUri, &charsRequired) != URI_SUCCESS) {
+    uriFreeUriMembersA(&parsedUri);
+    return uri;
+  }
+
+  std::string result(static_cast<size_t>(charsRequired), ' ');
+
+  if (uriToStringA(
+          const_cast<char*>(result.c_str()),
+          &parsedUri,
+          charsRequired + 1,
+          nullptr) != URI_SUCCESS) {
+    uriFreeUriMembersA(&parsedUri);
+    return uri;
+  }
+
+  return result;
+}
+
 } // namespace CesiumUtility

CesiumUtility/test/TestJoinToString.cpp

@@ -0,0 +1,22 @@
+#include <CesiumUtility/joinToString.h>
+
+#include <catch2/catch.hpp>
+
+using namespace CesiumUtility;
+
+TEST_CASE("joinToString") {
+  CHECK(
+      joinToString(std::vector<std::string>{"test", "this"}, "--") ==
+      "test--this");
+  CHECK(
+      joinToString(std::vector<std::string>{"test", "this", "thing"}, " ") ==
+      "test this thing");
+  CHECK(
+      joinToString(std::vector<std::string>{"test", "this", "thing"}, "") ==
+      "testthisthing");
+  CHECK(joinToString(std::vector<std::string>{"test"}, "--") == "test");
+  CHECK(joinToString(std::vector<std::string>{""}, "--") == "");
+  CHECK(joinToString(std::vector<std::string>{"", "aa", ""}, "--") == "--aa--");
+  CHECK(joinToString(std::vector<std::string>{"", ""}, "--") == "--");
+  CHECK(joinToString(std::vector<std::string>{}, "--") == "");
+}

CesiumUtility/test/TestUri.cpp

@@ -0,0 +1,58 @@
+#include <CesiumUtility/Uri.h>
+
+#include <catch2/catch.hpp>
+
+using namespace CesiumUtility;
+
+TEST_CASE("Uri::getPath") {
+  CHECK(Uri::getPath("https://example.com/") == "/");
+  CHECK(Uri::getPath("https://example.com/foo/bar") == "/foo/bar");
+  CHECK(Uri::getPath("https://example.com/foo/bar/") == "/foo/bar/");
+  CHECK(Uri::getPath("https://example.com/?some=parameter") == "/");
+  CHECK(
+      Uri::getPath("https://example.com/foo/bar?some=parameter") == "/foo/bar");
+  CHECK(
+      Uri::getPath("https://example.com/foo/bar/?some=parameter") ==
+      "/foo/bar/");
+  CHECK(Uri::getPath("https://example.com") == "");
+  CHECK(Uri::getPath("https://example.com?some=parameter") == "");
+  CHECK(Uri::getPath("not a valid uri") == "");
+}
+
+TEST_CASE("Uri::setPath") {
+  CHECK(Uri::setPath("https://example.com", "") == "https://example.com");
+  CHECK(
+      Uri::setPath("https://example.com?some=parameter", "") ==
+      "https://example.com?some=parameter");
+  CHECK(Uri::setPath("https://example.com", "/") == "https://example.com/");
+  CHECK(
+      Uri::setPath("https://example.com?some=parameter", "/") ==
+      "https://example.com/?some=parameter");
+  CHECK(
+      Uri::setPath("https://example.com/foo?some=parameter", "/bar") ==
+      "https://example.com/bar?some=parameter");
+  CHECK(
+      Uri::setPath("https://example.com/foo", "/bar") ==
+      "https://example.com/bar");
+  CHECK(
+      Uri::setPath("https://example.com/foo?some=parameter", "/bar") ==
+      "https://example.com/bar?some=parameter");
+  CHECK(
+      Uri::setPath("https://example.com/foo/", "/bar") ==
+      "https://example.com/bar");
+  CHECK(
+      Uri::setPath("https://example.com/foo/?some=parameter", "/bar") ==
+      "https://example.com/bar?some=parameter");
+  CHECK(
+      Uri::setPath("https://example.com/foo", "/bar/") ==
+      "https://example.com/bar/");
+  CHECK(
+      Uri::setPath("https://example.com/foo?some=parameter", "/bar/") ==
+      "https://example.com/bar/?some=parameter");
+  CHECK(
+      Uri::setPath("https://example.com/foo/bar", "/foo/bar") ==
+      "https://example.com/foo/bar");
+  CHECK(
+      Uri::setPath("https://example.com/foo/bar?some=parameter", "/foo/bar") ==
+      "https://example.com/foo/bar?some=parameter");
+}