Implement a new URI::rebase method (#1512)

Signed-off-by: Juan Cruz Viotti <[email protected]>

src/core/uri/include/sourcemeta/core/uri.h

@@ -323,6 +323,21 @@ class SOURCEMETA_CORE_URI_EXPORT URI {
   /// ```
   auto relative_to(const URI &base) -> URI &;
 
+  /// Attempt to change the base of a URI . If the URI is not
+  /// relative to the former, leave the URI intact. For example:
+  ///
+  /// ```cpp
+  /// #include <sourcemeta/core/uri.h>
+  /// #include <cassert>
+  ///
+  /// sourcemeta::core::URI uri{"https://example.com/foo/bar/baz"};
+  /// const sourcemeta::core::URI base{"https://example.com/foo"};
+  /// const sourcemeta::core::URI new_base{"/qux"};
+  /// uri.rebase(base, new_base);
+  /// assert(uri.recompose() == "/qux/bar/baz");
+  /// ```
+  auto rebase(const URI &base, const URI &new_base) -> URI &;
+
   /// Escape a string as established by RFC 3986 using C++ standard stream. For
   /// example:
   ///
@@ -383,7 +398,7 @@ class SOURCEMETA_CORE_URI_EXPORT URI {
 
 private:
   bool parsed = false;
-  auto parse_json() -> void;
+  auto parse() -> void;
 
 // Exporting symbols that depends on the standard C++ library is considered
 // safe.

src/core/uri/uri.cc

@@ -45,7 +45,7 @@ static auto uri_text_range(const UriTextRangeA *const range)
                               range->afterLast - range->first)};
 }
 
-static auto uri_parse_json(const std::string &data, UriUriA *uri) -> void {
+static auto uri_parse(const std::string &data, UriUriA *uri) -> void {
   const char *error_position;
   switch (uriParseSingleUriA(uri, data.c_str(), &error_position)) {
     case URI_ERROR_SYNTAX:
@@ -117,14 +117,14 @@ struct URI::Internal {
 };
 
 URI::URI(std::string input) : data{std::move(input)}, internal{new Internal} {
-  this->parse_json();
+  this->parse();
 }
 
 URI::URI(std::istream &input) : internal{new Internal} {
   std::ostringstream output;
   output << input.rdbuf();
   this->data = output.str();
-  this->parse_json();
+  this->parse();
 }
 
 URI::~URI() { uriFreeUriMembersA(&this->internal->uri); }
@@ -146,7 +146,7 @@ URI::URI(URI &&other)
   other.internal = nullptr;
 }
 
-auto URI::parse_json() -> void {
+auto URI::parse() -> void {
   if (this->parsed) {
     // clean
     this->path_ = std::nullopt;
@@ -163,7 +163,7 @@ auto URI::parse_json() -> void {
   // NOTE: we don't skip this line for fast path
   // as the internal structure of uriparser could still
   // be used by resolve_from and relative_to methods
-  uri_parse_json(this->data, &this->internal->uri);
+  uri_parse(this->data, &this->internal->uri);
 
   // Fast path for the root path
   if (this->data == "/") {
@@ -487,7 +487,7 @@ auto URI::resolve_from(const URI &base) -> URI & {
     uri_normalize(&absoluteDest);
     this->data = uri_to_string(&absoluteDest);
     uriFreeUriMembersA(&absoluteDest);
-    this->parse_json();
+    this->parse();
     return *this;
   } catch (...) {
     uriFreeUriMembersA(&absoluteDest);
@@ -530,20 +530,43 @@ auto URI::relative_to(const URI &base) -> URI & {
     copy.data.erase(0, 1);
   }
 
-  copy.parse_json();
+  copy.parse();
 
   // `uriparser` has this weird thing where it will only look at scheme and
   // authority, incorrectly thinking that a certain URI is a base of another one
   // if the path of the former exceeds the path of the latter. This is an ugly
   // workaround to prevent this non-sense.
   if (!copy.recompose().empty() || base.recompose() == this->recompose()) {
     this->data = std::move(copy.data);
-    this->parse_json();
+    this->parse();
   }
 
   return *this;
 }
 
+auto URI::rebase(const URI &base, const URI &new_base) -> URI & {
+  this->relative_to(base);
+  if (!this->is_relative()) {
+    return *this;
+  }
+
+  // TODO: We should be able to this with `resolve_from`,
+  // however that methow can't take a relative base yet
+  std::ostringstream new_uri;
+  const auto new_base_string{new_base.recompose()};
+  const auto new_uri_string{this->recompose()};
+
+  new_uri << new_base_string;
+  if (!new_base_string.ends_with('/') && !new_uri_string.empty()) {
+    new_uri << '/';
+  }
+  new_uri << new_uri_string;
+
+  this->data = std::move(URI{new_uri.str()}.data);
+  this->parse();
+  return *this;
+}
+
 auto URI::from_fragment(std::string_view fragment) -> URI {
   assert(fragment.empty() || fragment.front() != '#');
   std::ostringstream uri;

test/uri/CMakeLists.txt

@@ -14,6 +14,7 @@ sourcemeta_googletest(NAMESPACE sourcemeta PROJECT core NAME uri
     uri_is_tag_test.cc
     uri_is_mailto_test.cc
     uri_is_ipv6_test.cc
+    uri_rebase_test.cc
     uri_recompose_test.cc
     uri_recompose_without_fragment_test.cc
     uri_normalize_test.cc

test/uri/uri_rebase_test.cc

@@ -0,0 +1,27 @@
+#include <gtest/gtest.h>
+
+#include <sourcemeta/core/uri.h>
+
+TEST(URI_rebase, absolute_to_relative_match) {
+  sourcemeta::core::URI uri{"https://example.com/foo/bar/baz"};
+  const sourcemeta::core::URI base{"https://example.com/foo"};
+  const sourcemeta::core::URI new_base{"/qux"};
+  uri.rebase(base, new_base);
+  EXPECT_EQ(uri.recompose(), "/qux/bar/baz");
+}
+
+TEST(URI_rebase, absolute_to_relative_mismatch) {
+  sourcemeta::core::URI uri{"https://example.com/foo/bar/baz"};
+  const sourcemeta::core::URI base{"https://another.com/test"};
+  const sourcemeta::core::URI new_base{"/qux"};
+  uri.rebase(base, new_base);
+  EXPECT_EQ(uri.recompose(), "https://example.com/foo/bar/baz");
+}
+
+TEST(URI_rebase, absolute_to_relative_equal) {
+  sourcemeta::core::URI uri{"https://example.com/foo/bar/baz"};
+  const sourcemeta::core::URI base{"https://example.com/foo/bar/baz"};
+  const sourcemeta::core::URI new_base{"/qux"};
+  uri.rebase(base, new_base);
+  EXPECT_EQ(uri.recompose(), "/qux");
+}