FIX ATTEMPT

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

Author: jviotti

src/core/jsonschema/frame.cc

@@ -539,12 +539,11 @@ auto SchemaFrame::analyse(const JSON &root, const SchemaWalker &walker,
         entry.parent = path.concat(relative_entry.parent.value());
       }
 
-      // Dialect
+      // Dialect and Base dialect
       assert(entry.dialect.has_value());
-      base_dialects.insert({entry.pointer, {entry.dialect.value()}});
-
-      // Base dialect
       assert(entry.base_dialect.has_value());
+      base_dialects.insert(
+          {entry.pointer, {entry.dialect.value(), entry.base_dialect.value()}});
 
       // Schema identifier
       std::optional<JSON::String> id{sourcemeta::core::identify(
@@ -651,6 +650,21 @@ auto SchemaFrame::analyse(const JSON &root, const SchemaWalker &walker,
             }
           }
         }
+      } else if (!entry.id.has_value() &&
+                 entry.common.subschema.get().is_object() &&
+                 entry.common.subschema.get().defines("$schema") &&
+                 ref_overrides_adjacent_keywords(
+                     entry.common.base_dialect.value())) {
+        // Handle $schema without $id in Draft 7 and older
+        // Already inserted into base_dialects with both dialect and
+        // base_dialect above Just need to insert into base_uris with parent's
+        // base URI
+        const auto bases{
+            find_nearest_bases(base_uris, entry.common.pointer, std::nullopt)};
+        if (!bases.first.empty()) {
+          const auto &parent_base{bases.first.front()};
+          base_uris.insert({entry.common.pointer, {parent_base}});
+        }
       }
 
       if (this->mode_ != SchemaFrame::Mode::Locations) {
@@ -800,7 +814,7 @@ auto SchemaFrame::analyse(const JSON &root, const SchemaWalker &walker,
 
       const auto dialects{
           find_nearest_bases(base_dialects, pointer, root_dialect)};
-      assert(dialects.first.size() == 1);
+      assert(dialects.first.size() >= 1);
 
       auto every_base_result = find_every_base(base_uris, pointer);
 
@@ -826,10 +840,15 @@ auto SchemaFrame::analyse(const JSON &root, const SchemaWalker &walker,
           const auto maybe_base_entry{this->locations_.find(
               {SchemaReferenceType::Static, current_base})};
 
+          // Look up base_dialect from base_dialects (second element if present)
+          const auto base_dialect_result{
+              find_nearest_bases(base_dialects, pointer, root_dialect)};
           const auto current_base_dialect{
-              maybe_base_entry == this->locations_.cend()
-                  ? root_base_dialect.value()
-                  : maybe_base_entry->second.base_dialect};
+              base_dialect_result.first.size() >= 2
+                  ? base_dialect_result.first[1]
+                  : (maybe_base_entry == this->locations_.cend()
+                         ? root_base_dialect.value()
+                         : maybe_base_entry->second.base_dialect)};
 
           const auto subschema{subschemas.find(pointer)};
 

src/core/jsonschema/walker.cc

@@ -49,6 +49,9 @@ auto walk(const std::optional<sourcemeta::core::Pointer> &parent,
   // / base dialect and ignore the invalid standalone `$schema`. The caller has
   // enough information to detect those cases and throw an error if they desire
   // to be more strict.
+  //
+  // However, this is a 2020-12 restriction and we CAN accept `$schema` without
+  // an identifier on older versions
   const auto maybe_current_dialect{
       sourcemeta::core::dialect(subschema, dialect)};
   assert(maybe_current_dialect.has_value());
@@ -57,13 +60,26 @@ auto walk(const std::optional<sourcemeta::core::Pointer> &parent,
       sourcemeta::core::SchemaIdentificationStrategy::Strict,
       maybe_current_dialect)};
   const auto is_schema_resource{level == 0 || id.has_value()};
-  const auto current_dialect{is_schema_resource ? maybe_current_dialect.value()
-                                                : dialect};
-  const auto current_base_dialect{
-      is_schema_resource
-          ? sourcemeta::core::base_dialect(subschema, resolver, current_dialect)
-                .value_or(base_dialect)
-          : base_dialect};
+  const auto has_schema_keyword{subschema.is_object() &&
+                                subschema.defines("$schema")};
+  const auto subschema_base_dialect{
+      has_schema_keyword ? sourcemeta::core::base_dialect(subschema, resolver,
+                                                          maybe_current_dialect)
+                               .value_or(base_dialect)
+                         : base_dialect};
+  const auto should_process_schema_without_id{
+      has_schema_keyword &&
+      ref_overrides_adjacent_keywords(subschema_base_dialect)};
+  const auto current_dialect{is_schema_resource ||
+                                     should_process_schema_without_id
+                                 ? maybe_current_dialect.value()
+                                 : dialect};
+  const auto current_base_dialect{is_schema_resource ||
+                                          should_process_schema_without_id
+                                      ? subschema_base_dialect
+                                      : base_dialect};
+  const auto current_ref_overrides{
+      ref_overrides_adjacent_keywords(current_base_dialect)};
 
   const auto vocabularies{sourcemeta::core::vocabularies(
       resolver, current_base_dialect, current_dialect)};
@@ -88,9 +104,8 @@ auto walk(const std::optional<sourcemeta::core::Pointer> &parent,
     return;
   }
 
-  const auto has_overriding_ref{
-      subschema.defines("$ref") &&
-      ref_overrides_adjacent_keywords(current_base_dialect)};
+  const auto has_overriding_ref{subschema.defines("$ref") &&
+                                current_ref_overrides};
   for (auto &pair : subschema.as_object()) {
     const auto keyword_info{walker(pair.first, vocabularies)};