Fix relative $ref on relative path $id (#1580)

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

Author: jviotti

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

@@ -295,6 +295,10 @@ class SOURCEMETA_CORE_URI_EXPORT URI {
   /// ```
   auto resolve_from(const URI &base) -> URI &;
 
+  // TODO: Do we really need this `try_resolve_from` method? There shouldn't
+  // be any reason why resolution cannot happen. This is probably just an
+  // artifact of `uriparser` not supporting relative resolution
+
   /// Resolve a relative URI against a base URI as established by RFC
   /// 3986. If the resolution cannot happen, nothing happens. For example:
   ///
@@ -420,7 +424,7 @@ class SOURCEMETA_CORE_URI_EXPORT URI {
   std::optional<std::string> query_;
   bool is_ipv6_ = false;
 
-  // Use PIMPL idiom to hide `urlparser`
+  // Use PIMPL idiom to hide `uriparser`
   struct Internal;
   std::unique_ptr<Internal> internal;
 #if defined(_MSC_VER)

src/core/uri/uri.cc

@@ -583,7 +583,9 @@ auto URI::try_resolve_from(const URI &base) -> URI & {
     return this->resolve_from(base);
 
     // TODO: This only handles a very specific case. We should generalize this
-    // function to perform proper base resolution on relative bases
+    // function to perform proper base resolution on relative bases instead of
+    // doing these one-off workarounds
+
   } else if (this->is_fragment_only() && !base.fragment().has_value()) {
     this->data = base.data;
     this->path_ = base.path_;
@@ -593,7 +595,20 @@ auto URI::try_resolve_from(const URI &base) -> URI & {
     this->scheme_ = base.scheme_;
     this->query_ = base.query_;
     return *this;
-
+  } else if (base.path().has_value() && base.path().value().starts_with("..")) {
+    return *this;
+  } else if (base.is_relative() && this->is_relative() &&
+             base.path_.has_value() && this->path_.has_value() &&
+             this->path_.value().find('/') == std::string::npos &&
+             !base.recompose().starts_with('/')) {
+    assert(base.is_relative());
+    URI absolute_base{"https://stub.local/" + base.recompose()};
+    assert(absolute_base.is_absolute());
+    auto copy = *this;
+    copy.resolve_from(absolute_base);
+    this->data = copy.recompose().substr(19);
+    this->parse();
+    return *this;
   } else {
     return *this;
   }

test/jsonschema/jsonschema_frame_2020_12_test.cc

@@ -1728,6 +1728,44 @@ TEST(JSONSchema_frame_2020_12, relative_base_uri_with_ref) {
                           "foo");
 }
 
+TEST(JSONSchema_frame_2020_12, relative_base_with_relative_path_ref) {
+  const sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "$id": "foo/bar/baz",
+    "$ref": "qux"
+  })JSON");
+
+  sourcemeta::core::SchemaFrame frame{
+      sourcemeta::core::SchemaFrame::Mode::Instances};
+  frame.analyse(document, sourcemeta::core::schema_official_walker,
+                sourcemeta::core::schema_official_resolver);
+
+  EXPECT_EQ(frame.locations().size(), 4);
+
+  EXPECT_FRAME_STATIC_2020_12_RESOURCE(frame, "foo/bar/baz", "foo/bar/baz", "",
+                                       "foo/bar/baz", "", {""}, std::nullopt);
+
+  // JSON Pointers
+
+  EXPECT_FRAME_STATIC_2020_12_POINTER(frame, "foo/bar/baz#/$schema",
+                                      "foo/bar/baz", "/$schema", "foo/bar/baz",
+                                      "/$schema", {}, "");
+  EXPECT_FRAME_STATIC_2020_12_POINTER(frame, "foo/bar/baz#/$id", "foo/bar/baz",
+                                      "/$id", "foo/bar/baz", "/$id", {}, "");
+  EXPECT_FRAME_STATIC_2020_12_POINTER(frame, "foo/bar/baz#/$ref", "foo/bar/baz",
+                                      "/$ref", "foo/bar/baz", "/$ref", {}, "");
+
+  // References
+
+  EXPECT_EQ(frame.references().size(), 2);
+
+  EXPECT_STATIC_REFERENCE(
+      frame, "/$schema", "https://json-schema.org/draft/2020-12/schema",
+      "https://json-schema.org/draft/2020-12/schema", std::nullopt);
+  EXPECT_STATIC_REFERENCE(frame, "/$ref", "foo/bar/qux", "foo/bar/qux",
+                          std::nullopt);
+}
+
 TEST(JSONSchema_frame_2020_12, idempotent_with_refs) {
   const sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({
     "$id": "https://www.sourcemeta.com/schema",

test/uri/uri_resolve_from_test.cc

@@ -63,6 +63,13 @@ TEST(URI_try_resolve_from, base_relative_path_leading_slash) {
   EXPECT_EQ(relative.recompose(), "/foo#/bar");
 }
 
+TEST(URI_try_resolve_from, relative_path_from_relative_path) {
+  const sourcemeta::core::URI base{"foo/bar/baz"};
+  sourcemeta::core::URI relative{"qux"};
+  relative.try_resolve_from(base);
+  EXPECT_EQ(relative.recompose(), "foo/bar/qux");
+}
+
 // RFC 3986, inspired from
 // https://cr.openjdk.org/~dfuchs/writeups/updating-uri/A Section "Resolutuon"