Introduce bundling modes to opt-out from meta schema bundling (#853)

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

Author: jviotti

benchmark/bundle.cc

@@ -10,8 +10,10 @@ static void Schema_Bundle_Meta_2020_12(benchmark::State &state) {
                     "https://json-schema.org/draft/2020-12/schema")
                     .value()};
     state.ResumeTiming();
-    sourcemeta::blaze::bundle(schema, sourcemeta::blaze::schema_walker,
-                              sourcemeta::blaze::schema_resolver);
+    sourcemeta::blaze::bundle(
+        schema, sourcemeta::blaze::schema_walker,
+        sourcemeta::blaze::schema_resolver,
+        sourcemeta::blaze::BundleMode::NonOfficialMetaschemas);
     benchmark::DoNotOptimize(schema);
   }
 }

src/bundle/bundle.cc

@@ -16,12 +16,17 @@
 
 namespace {
 
-auto is_official_metaschema_reference(
+auto is_skippable_metaschema_reference(
+    const sourcemeta::blaze::BundleMode mode,
     const sourcemeta::core::WeakPointer &pointer,
     const std::string &destination) -> bool {
   assert(!pointer.empty());
   assert(pointer.back().is_property());
-  return pointer.back().to_property() == "$schema" &&
+  if (pointer.back().to_property() != "$schema") {
+    return false;
+  }
+
+  return mode == sourcemeta::blaze::BundleMode::References ||
          sourcemeta::blaze::is_official_schema(destination);
 }
 
@@ -47,7 +52,9 @@ auto dependencies_internal(
                                           const auto &reference) {
     // We don't want to report official schemas, as we can expect
     // virtually all implementations to understand them out of the box
-    if (is_official_metaschema_reference(pointer, reference.destination)) {
+    if (is_skippable_metaschema_reference(
+            sourcemeta::blaze::BundleMode::NonOfficialMetaschemas, pointer,
+            reference.destination)) {
       return;
     }
 
@@ -236,6 +243,7 @@ auto bundle_schema(sourcemeta::core::JSON &root,
                    sourcemeta::core::JSON &subschema,
                    const sourcemeta::blaze::SchemaWalker &walker,
                    const sourcemeta::blaze::SchemaResolver &resolver,
+                   const sourcemeta::blaze::BundleMode mode,
                    std::string_view default_dialect,
                    std::string_view default_id,
                    const sourcemeta::blaze::SchemaFrame::Paths &paths,
@@ -265,8 +273,10 @@ auto bundle_schema(sourcemeta::core::JSON &root,
   frame.for_each_unresolved_reference([&](const auto &pointer,
                                           const auto &reference) {
     // We don't want to bundle official schemas, as we can expect
-    // virtually all implementations to understand them out of the box
-    if (is_official_metaschema_reference(pointer, reference.destination)) {
+    // virtually all implementations to understand them out of the box.
+    // Depending on the bundling strategy, we may skip meta-schemas entirely
+    if (is_skippable_metaschema_reference(mode, pointer,
+                                          reference.destination)) {
       return;
     }
 
@@ -378,8 +388,8 @@ auto bundle_schema(sourcemeta::core::JSON &root,
   }
 
   for (auto &[remote, effective_id, remote_dialect] : deferred) {
-    bundle_schema(root, container, remote, walker, resolver, default_dialect,
-                  effective_id, paths, bundled, depth + 1);
+    bundle_schema(root, container, remote, walker, resolver, mode,
+                  default_dialect, effective_id, paths, bundled, depth + 1);
     elevate_embedded_resources(remote, root, container, remote_dialect,
                                resolver, default_dialect, bundled);
     embed_schema(root, container, effective_id, std::move(remote));
@@ -403,8 +413,8 @@ auto dependencies(const sourcemeta::core::JSON &schema,
 // TODO: Refactor this function to internally rely on the `.dependencies()`
 // function
 auto bundle(sourcemeta::core::JSON &schema, const SchemaWalker &walker,
-            const SchemaResolver &resolver, std::string_view default_dialect,
-            std::string_view default_id,
+            const SchemaResolver &resolver, const BundleMode mode,
+            std::string_view default_dialect, std::string_view default_id,
             const std::optional<sourcemeta::core::Pointer> &default_container,
             const SchemaFrame::Paths &paths) -> void {
   // Pre-scan the schema to find any already-embedded schemas and mark them
@@ -424,7 +434,7 @@ auto bundle(sourcemeta::core::JSON &schema, const SchemaWalker &walker,
     // This is undefined behavior
     assert(!default_container.value().empty());
     bundle_schema(schema, default_container.value(), schema, walker, resolver,
-                  default_dialect, default_id, paths, bundled);
+                  mode, default_dialect, default_id, paths, bundled);
     return;
   }
 
@@ -477,18 +487,18 @@ auto bundle(sourcemeta::core::JSON &schema, const SchemaWalker &walker,
   }
 
   bundle_schema(schema, {sourcemeta::core::JSON::String{container_keyword}},
-                schema, walker, resolver, default_dialect, default_id, paths,
-                bundled);
+                schema, walker, resolver, mode, default_dialect, default_id,
+                paths, bundled);
 }
 
 auto bundle(const sourcemeta::core::JSON &schema, const SchemaWalker &walker,
-            const SchemaResolver &resolver, std::string_view default_dialect,
-            std::string_view default_id,
+            const SchemaResolver &resolver, const BundleMode mode,
+            std::string_view default_dialect, std::string_view default_id,
             const std::optional<sourcemeta::core::Pointer> &default_container,
             const SchemaFrame::Paths &paths) -> sourcemeta::core::JSON {
   sourcemeta::core::JSON copy = schema;
-  bundle(copy, walker, resolver, default_dialect, default_id, default_container,
-         paths);
+  bundle(copy, walker, resolver, mode, default_dialect, default_id,
+         default_container, paths);
   return copy;
 }
 

src/bundle/include/sourcemeta/blaze/bundle.h

@@ -20,6 +20,7 @@
 #include <sourcemeta/blaze/foundation.h>
 #include <sourcemeta/blaze/frame.h>
 
+#include <cstdint>     // std::uint8_t
 #include <functional>  // std::function
 #include <optional>    // std::optional, std::nullopt
 #include <string_view> // std::string_view
@@ -36,6 +37,18 @@ using DependencyCallback =
     std::function<void(std::string_view, const sourcemeta::core::WeakPointer &,
                        std::string_view, const sourcemeta::core::JSON &)>;
 
+/// @ingroup bundle
+/// The strategies that the bundling process can follow
+enum class BundleMode : std::uint8_t {
+  /// Embed every external reference, including any non-official
+  /// meta-schemas that the schema or its dependencies declare, along
+  /// with the dependencies of those meta-schemas
+  NonOfficialMetaschemas,
+  /// Embed every external reference, skipping meta-schema
+  /// declarations entirely
+  References
+};
+
 /// @ingroup bundle
 ///
 /// This function recursively traverses and reports the external references in a
@@ -117,7 +130,8 @@ auto dependencies(const sourcemeta::core::JSON &schema,
 /// })JSON");
 ///
 /// sourcemeta::blaze::bundle(document,
-///   sourcemeta::blaze::schema_walker, test_resolver);
+///   sourcemeta::blaze::schema_walker, test_resolver,
+///   sourcemeta::blaze::BundleMode::NonOfficialMetaschemas);
 ///
 /// const sourcemeta::core::JSON expected =
 ///     sourcemeta::core::parse_json(R"JSON({
@@ -136,7 +150,7 @@ auto dependencies(const sourcemeta::core::JSON &schema,
 /// ```
 SOURCEMETA_BLAZE_BUNDLE_EXPORT
 auto bundle(sourcemeta::core::JSON &schema, const SchemaWalker &walker,
-            const SchemaResolver &resolver,
+            const SchemaResolver &resolver, const BundleMode mode,
             std::string_view default_dialect = "",
             std::string_view default_id = "",
             const std::optional<sourcemeta::core::Pointer> &default_container =
@@ -179,7 +193,8 @@ auto bundle(sourcemeta::core::JSON &schema, const SchemaWalker &walker,
 ///
 /// const sourcemeta::core::JSON result =
 ///   sourcemeta::blaze::bundle(document,
-///     sourcemeta::blaze::schema_walker, test_resolver);
+///     sourcemeta::blaze::schema_walker, test_resolver,
+///     sourcemeta::blaze::BundleMode::NonOfficialMetaschemas);
 ///
 /// const sourcemeta::core::JSON expected =
 ///     sourcemeta::core::parse_json(R"JSON({
@@ -199,8 +214,8 @@ auto bundle(sourcemeta::core::JSON &schema, const SchemaWalker &walker,
 SOURCEMETA_BLAZE_BUNDLE_EXPORT
 auto bundle(
     const sourcemeta::core::JSON &schema, const SchemaWalker &walker,
-    const SchemaResolver &resolver, std::string_view default_dialect = "",
-    std::string_view default_id = "",
+    const SchemaResolver &resolver, const BundleMode mode,
+    std::string_view default_dialect = "", std::string_view default_id = "",
     const std::optional<sourcemeta::core::Pointer> &default_container =
         std::nullopt,
     const SchemaFrame::Paths &paths = {sourcemeta::core::empty_weak_pointer})

src/codegen/codegen.cc

@@ -62,8 +62,9 @@ auto compile(const sourcemeta::core::JSON &input,
   // (1) Bundle the schema to resolve external references
   // --------------------------------------------------------------------------
 
-  auto schema{sourcemeta::blaze::bundle(input, walker, resolver,
-                                        default_dialect, default_id)};
+  auto schema{sourcemeta::blaze::bundle(
+      input, walker, resolver, sourcemeta::blaze::BundleMode::References,
+      default_dialect, default_id)};
 
   // --------------------------------------------------------------------------
   // (2) Canonicalize the schema for easier analysis

src/compiler/compile.cc

@@ -439,9 +439,11 @@ auto compile(const sourcemeta::core::JSON &schema,
   assert(is_schema(schema));
 
   // Make sure the input schema is bundled, otherwise we won't be able to
-  // resolve remote references here
+  // resolve remote references here. Meta-schemas are not needed, as we
+  // can determine vocabularies through the resolver
   const sourcemeta::core::JSON result{sourcemeta::blaze::bundle(
-      schema, walker, resolver, default_dialect, default_id)};
+      schema, walker, resolver, sourcemeta::blaze::BundleMode::References,
+      default_dialect, default_id)};
 
   sourcemeta::blaze::SchemaFrame frame{
       sourcemeta::blaze::SchemaFrame::Mode::References};

src/configuration/fetch.cc

@@ -117,8 +117,10 @@ auto fetch_and_write(
 
   try {
     const std::string default_dialect_value{default_dialect.value_or("")};
-    sourcemeta::blaze::bundle(out_schema, sourcemeta::blaze::schema_walker,
-                              resolver, default_dialect_value, dependency_uri);
+    sourcemeta::blaze::bundle(
+        out_schema, sourcemeta::blaze::schema_walker, resolver,
+        sourcemeta::blaze::BundleMode::NonOfficialMetaschemas,
+        default_dialect_value, dependency_uri);
   } catch (...) {
     emit_event(callback, FetchEvent::Type::Error, dependency_uri,
                dependency_path, index, total, "Failed to bundle schema",

src/editor/include/sourcemeta/blaze/editor.h

@@ -35,6 +35,7 @@ namespace sourcemeta::blaze {
 ///
 /// ```cpp
 /// #include <sourcemeta/core/json.h>
+/// #include <sourcemeta/blaze/bundle.h>
 /// #include <sourcemeta/blaze/foundation.h>
 /// #include <sourcemeta/blaze/editor.h>
 ///
@@ -46,7 +47,8 @@ namespace sourcemeta::blaze {
 ///
 /// sourcemeta::blaze::bundle(schema,
 ///   sourcemeta::blaze::schema_walker,
-///   sourcemeta::blaze::schema_resolver);
+///   sourcemeta::blaze::schema_resolver,
+///   sourcemeta::blaze::BundleMode::NonOfficialMetaschemas);
 /// sourcemeta::blaze::for_editor(schema,
 ///   sourcemeta::blaze::schema_walker,
 ///   sourcemeta::blaze::schema_resolver);