Improve handling of top-level $ref before 2019-09 (#1507)

Signed-off-by: Juan Cruz Viotti <jv@jviotti.com>

src/core/jsonschema/jsonschema.cc

@@ -9,6 +9,8 @@
 #include <type_traits> // std::remove_reference_t
 #include <utility>     // std::move
 
+#include <iostream>
+
 auto sourcemeta::core::is_schema(const sourcemeta::core::JSON &schema) -> bool {
   return schema.is_object() || schema.is_boolean();
 }
@@ -96,7 +98,17 @@ auto sourcemeta::core::identify(
     return default_id;
   }
 
-  return identify(schema, maybe_base_dialect.value(), default_id);
+  const auto result{identify(schema, maybe_base_dialect.value(), default_id)};
+
+  // A last shot supporting identifiers alongside `$ref` in loose mode
+  if (!result.has_value() && strategy == SchemaIdentificationStrategy::Loose) {
+    const auto keyword{id_keyword(maybe_base_dialect.value())};
+    if (schema.defines(keyword) && schema.at(keyword).is_string()) {
+      return schema.at(keyword).to_string();
+    }
+  }
+
+  return result;
 }
 
 auto sourcemeta::core::identify(const JSON &schema,
@@ -108,6 +120,7 @@ auto sourcemeta::core::identify(const JSON &schema,
   }
 
   const auto keyword{id_keyword(base_dialect)};
+
   if (!schema.defines(keyword)) {
     return default_id;
   }

src/core/jsonschema/resolver.cc

@@ -101,23 +101,25 @@ auto SchemaFlatFileResolver::add(
   const auto identifier{sourcemeta::core::identify(
       schema, *this, SchemaIdentificationStrategy::Loose, default_dialect,
       default_id)};
-  if (!identifier.has_value()) {
+  if (!identifier.has_value() && !default_id.has_value()) {
     std::ostringstream error;
     error << "Cannot identify schema: " << canonical.string();
     throw SchemaError(error.str());
   }
 
   // Filesystems behave differently with regards to casing. To unify
   // them, assume they are case-insensitive.
-  const auto effective_identifier{to_lowercase(identifier.value())};
+  const auto effective_identifier{to_lowercase(
+      default_id.has_value() ? identifier.value_or(default_id.value())
+                             : identifier.value())};
 
   const auto result{this->schemas.emplace(
       effective_identifier,
       Entry{canonical, default_dialect, effective_identifier, reader})};
   if (!result.second && result.first->second.path != canonical) {
     std::ostringstream error;
     error << "Cannot register the same identifier twice: "
-          << identifier.value();
+          << effective_identifier;
     throw SchemaError(error.str());
   }
 

test/jsonschema/jsonschema_flat_file_resolver_test.cc

@@ -61,7 +61,8 @@ TEST(JSONSchema_SchemaFlatFileResolver, single_schema_with_default_dialect) {
             expected);
 }
 
-TEST(JSONSchema_SchemaFlatFileResolver, single_schema_anonymous_with_default) {
+TEST(JSONSchema_SchemaFlatFileResolver,
+     single_schema_anonymous_with_default_id) {
   sourcemeta::core::SchemaFlatFileResolver resolver;
   const auto schema_path{std::filesystem::path{SCHEMAS_PATH} /
                          "2020-12-anonymous.json"};
@@ -78,6 +79,31 @@ TEST(JSONSchema_SchemaFlatFileResolver, single_schema_anonymous_with_default) {
   EXPECT_EQ(resolver("https://www.sourcemeta.com/test").value(), expected);
 }
 
+TEST(JSONSchema_SchemaFlatFileResolver, draft4_top_level_ref) {
+  sourcemeta::core::SchemaFlatFileResolver resolver;
+  const auto schema_path{std::filesystem::path{SCHEMAS_PATH} /
+                         "draft4-top-level-ref.json"};
+
+  const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({
+    "$schema": "http://json-schema.org/draft-04/schema#",
+    "id": "https://www.sourcemeta.com/draft4-top-level-ref.json",
+    "allOf": [ { "$ref": "#/definitions/foo" } ],
+    "definitions": {
+      "foo": {
+        "type": "string"
+      }
+    }
+  })JSON");
+
+  const auto &identifier{resolver.add(schema_path)};
+  EXPECT_EQ(identifier, "https://www.sourcemeta.com/draft4-top-level-ref.json");
+  EXPECT_TRUE(resolver("https://www.sourcemeta.com/draft4-top-level-ref.json")
+                  .has_value());
+  EXPECT_EQ(
+      resolver("https://www.sourcemeta.com/draft4-top-level-ref.json").value(),
+      expected);
+}
+
 TEST(JSONSchema_SchemaFlatFileResolver, single_schema_idempotent) {
   sourcemeta::core::SchemaFlatFileResolver resolver;
   const auto schema_path{std::filesystem::path{SCHEMAS_PATH} /

test/jsonschema/jsonschema_identify_test.cc

@@ -205,6 +205,41 @@ TEST(JSONSchema_identify, loose_with_resolvable_default_dialect) {
   EXPECT_EQ(id.value(), "http://example.com/my-schema");
 }
 
+TEST(JSONSchema_identify, strict_draft4_top_level_ref) {
+  const sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({
+    "$schema": "http://json-schema.org/draft-04/schema#",
+    "id": "http://example.com/my-schema",
+    "$ref": "#/definitions/foo",
+    "definitions": {
+      "foo": {
+        "type": "string"
+      }
+    }
+  })JSON");
+  std::optional<std::string> id{sourcemeta::core::identify(
+      document, sourcemeta::core::schema_official_resolver,
+      sourcemeta::core::SchemaIdentificationStrategy::Strict)};
+  EXPECT_FALSE(id.has_value());
+}
+
+TEST(JSONSchema_identify, loose_draft4_top_level_ref) {
+  const sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({
+    "$schema": "http://json-schema.org/draft-04/schema#",
+    "id": "http://example.com/my-schema",
+    "$ref": "#/definitions/foo",
+    "definitions": {
+      "foo": {
+        "type": "string"
+      }
+    }
+  })JSON");
+  std::optional<std::string> id{sourcemeta::core::identify(
+      document, sourcemeta::core::schema_official_resolver,
+      sourcemeta::core::SchemaIdentificationStrategy::Loose)};
+  EXPECT_TRUE(id.has_value());
+  EXPECT_EQ(id.value(), "http://example.com/my-schema");
+}
+
 TEST(JSONSchema_identify, loose_with_unresolvable_dialect) {
   const sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({
     "$id": "https://example.com/my-schema",

test/jsonschema/schemas/draft4-top-level-ref.json

@@ -0,0 +1,10 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "id": "https://www.sourcemeta.com/draft4-top-level-ref.json",
+  "$ref": "#/definitions/foo",
+  "definitions": {
+    "foo": {
+      "type": "string"
+    }
+  }
+}