Upgrade Sourcemeta Core to the latest version

DEPENDENCIES

@@ -1,3 +1,3 @@
 vendorpull https://github.com/sourcemeta/vendorpull 70342aaf458e6cb80baeb5b718901075fc42ede6
-core https://github.com/sourcemeta/core 918a17d1e4f82a12334bf99d67ffef4e77fd6722
+core https://github.com/sourcemeta/core bf0868140c6adc6e58bc3be074ea9ed9ed1efd05
 bootstrap https://github.com/twbs/bootstrap 1a6fdfae6be09b09eaced8f0e442ca6f7680a61e

config.cmake.in

@@ -10,7 +10,7 @@ if(NOT JSONBINPACK_COMPONENTS)
 endif()
 
 include(CMakeFindDependencyMacro)
-find_dependency(Core COMPONENTS uri json jsonpointer jsonschema alterschema)
+find_dependency(Core COMPONENTS regex uri json jsonpointer jsonschema alterschema)
 
 foreach(component ${JSONBINPACK_COMPONENTS})
   if(component STREQUAL "numeric")

src/compiler/compiler.cc

@@ -27,10 +27,10 @@ auto canonicalize(sourcemeta::core::JSON &schema,
                       sourcemeta::core::empty_pointer, default_dialect);
 }
 
-auto make_encoding(sourcemeta::core::PointerProxy &document,
+auto make_encoding(sourcemeta::core::JSON &document,
                    const std::string &encoding,
                    const sourcemeta::core::JSON &options) -> void {
-  document.replace(sourcemeta::core::JSON::make_object());
+  document.into_object();
   document.assign("$schema", sourcemeta::core::JSON{ENCODING_V1});
   document.assign("binpackEncoding", sourcemeta::core::JSON{encoding});
   document.assign("binpackOptions", options);
@@ -87,8 +87,7 @@ auto compile(sourcemeta::core::JSON &schema,
   // The "any" encoding is always the last resort
   const auto dialect{sourcemeta::core::dialect(schema)};
   if (!dialect.has_value() || dialect.value() != ENCODING_V1) {
-    sourcemeta::core::PointerProxy transformer{schema};
-    make_encoding(transformer, "ANY_PACKED_TYPE_TAG_BYTE_PREFIX",
+    make_encoding(schema, "ANY_PACKED_TYPE_TAG_BYTE_PREFIX",
                   sourcemeta::core::JSON::make_object());
   }
 }

src/compiler/mapper/enum_8_bit.h

@@ -16,10 +16,9 @@ class Enum8Bit final : public sourcemeta::core::SchemaTransformRule {
            is_byte(schema.at("enum").size() - 1);
   }
 
-  auto transform(sourcemeta::core::PointerProxy &transformer) const
-      -> void override {
+  auto transform(sourcemeta::core::JSON &schema) const -> void override {
     auto options = sourcemeta::core::JSON::make_object();
-    options.assign("choices", transformer.value().at("enum"));
-    make_encoding(transformer, "BYTE_CHOICE_INDEX", options);
+    options.assign("choices", schema.at("enum"));
+    make_encoding(schema, "BYTE_CHOICE_INDEX", options);
   }
 };

src/compiler/mapper/enum_8_bit_top_level.h

@@ -16,10 +16,9 @@ class Enum8BitTopLevel final : public sourcemeta::core::SchemaTransformRule {
            is_byte(schema.at("enum").size() - 1);
   }
 
-  auto transform(sourcemeta::core::PointerProxy &transformer) const
-      -> void override {
+  auto transform(sourcemeta::core::JSON &schema) const -> void override {
     auto options = sourcemeta::core::JSON::make_object();
-    options.assign("choices", transformer.value().at("enum"));
-    make_encoding(transformer, "TOP_LEVEL_BYTE_CHOICE_INDEX", options);
+    options.assign("choices", schema.at("enum"));
+    make_encoding(schema, "TOP_LEVEL_BYTE_CHOICE_INDEX", options);
   }
 };

src/compiler/mapper/enum_arbitrary.h

@@ -17,10 +17,9 @@ class EnumArbitrary final : public sourcemeta::core::SchemaTransformRule {
            !is_byte(schema.at("enum").size() - 1);
   }
 
-  auto transform(sourcemeta::core::PointerProxy &transformer) const
-      -> void override {
+  auto transform(sourcemeta::core::JSON &schema) const -> void override {
     auto options = sourcemeta::core::JSON::make_object();
-    options.assign("choices", transformer.value().at("enum"));
-    make_encoding(transformer, "LARGE_CHOICE_INDEX", options);
+    options.assign("choices", schema.at("enum"));
+    make_encoding(schema, "LARGE_CHOICE_INDEX", options);
   }
 };

src/compiler/mapper/enum_singleton.h

@@ -15,10 +15,9 @@ class EnumSingleton final : public sourcemeta::core::SchemaTransformRule {
            schema.at("enum").size() == 1;
   }
 
-  auto transform(sourcemeta::core::PointerProxy &transformer) const
-      -> void override {
+  auto transform(sourcemeta::core::JSON &schema) const -> void override {
     auto options = sourcemeta::core::JSON::make_object();
-    options.assign("value", transformer.value().at("enum").at(0));
-    make_encoding(transformer, "CONST_NONE", options);
+    options.assign("value", schema.at("enum").at(0));
+    make_encoding(schema, "CONST_NONE", options);
   }
 };

src/compiler/mapper/integer_bounded_8_bit.h

@@ -19,14 +19,13 @@ class IntegerBounded8Bit final : public sourcemeta::core::SchemaTransformRule {
            !schema.defines("multipleOf");
   }
 
-  auto transform(sourcemeta::core::PointerProxy &transformer) const
-      -> void override {
-    auto minimum = transformer.value().at("minimum");
-    auto maximum = transformer.value().at("maximum");
+  auto transform(sourcemeta::core::JSON &schema) const -> void override {
+    auto minimum = schema.at("minimum");
+    auto maximum = schema.at("maximum");
     auto options = sourcemeta::core::JSON::make_object();
     options.assign("minimum", std::move(minimum));
     options.assign("maximum", std::move(maximum));
     options.assign("multiplier", sourcemeta::core::JSON{1});
-    make_encoding(transformer, "BOUNDED_MULTIPLE_8BITS_ENUM_FIXED", options);
+    make_encoding(schema, "BOUNDED_MULTIPLE_8BITS_ENUM_FIXED", options);
   }
 };

src/compiler/mapper/integer_bounded_greater_than_8_bit.h

@@ -21,12 +21,11 @@ class IntegerBoundedGreaterThan8Bit final
            !schema.defines("multipleOf");
   }
 
-  auto transform(sourcemeta::core::PointerProxy &transformer) const
-      -> void override {
-    auto minimum = transformer.value().at("minimum");
+  auto transform(sourcemeta::core::JSON &schema) const -> void override {
+    auto minimum = schema.at("minimum");
     auto options = sourcemeta::core::JSON::make_object();
     options.assign("minimum", std::move(minimum));
     options.assign("multiplier", sourcemeta::core::JSON{1});
-    make_encoding(transformer, "FLOOR_MULTIPLE_ENUM_VARINT", options);
+    make_encoding(schema, "FLOOR_MULTIPLE_ENUM_VARINT", options);
   }
 };

src/compiler/mapper/integer_bounded_multiplier_8_bit.h

@@ -26,16 +26,15 @@ class IntegerBoundedMultiplier8Bit final
                                    schema.at("multipleOf").to_integer()));
   }
 
-  auto transform(sourcemeta::core::PointerProxy &transformer) const
-      -> void override {
-    auto minimum = transformer.value().at("minimum");
-    auto maximum = transformer.value().at("maximum");
-    auto multiplier = transformer.value().at("multipleOf");
+  auto transform(sourcemeta::core::JSON &schema) const -> void override {
+    auto minimum = schema.at("minimum");
+    auto maximum = schema.at("maximum");
+    auto multiplier = schema.at("multipleOf");
 
     auto options = sourcemeta::core::JSON::make_object();
     options.assign("minimum", std::move(minimum));
     options.assign("maximum", std::move(maximum));
     options.assign("multiplier", std::move(multiplier));
-    make_encoding(transformer, "BOUNDED_MULTIPLE_8BITS_ENUM_FIXED", options);
+    make_encoding(schema, "BOUNDED_MULTIPLE_8BITS_ENUM_FIXED", options);
   }
 };

src/compiler/mapper/integer_bounded_multiplier_greater_than_8_bit.h

@@ -26,13 +26,12 @@ class IntegerBoundedMultiplierGreaterThan8Bit final
                                     schema.at("multipleOf").to_integer()));
   }
 
-  auto transform(sourcemeta::core::PointerProxy &transformer) const
-      -> void override {
-    auto minimum = transformer.value().at("minimum");
-    auto multiplier = transformer.value().at("multipleOf");
+  auto transform(sourcemeta::core::JSON &schema) const -> void override {
+    auto minimum = schema.at("minimum");
+    auto multiplier = schema.at("multipleOf");
     auto options = sourcemeta::core::JSON::make_object();
     options.assign("minimum", std::move(minimum));
     options.assign("multiplier", std::move(multiplier));
-    make_encoding(transformer, "FLOOR_MULTIPLE_ENUM_VARINT", options);
+    make_encoding(schema, "FLOOR_MULTIPLE_ENUM_VARINT", options);
   }
 };

src/compiler/mapper/integer_lower_bound.h

@@ -17,12 +17,11 @@ class IntegerLowerBound final : public sourcemeta::core::SchemaTransformRule {
            !schema.defines("multipleOf");
   }
 
-  auto transform(sourcemeta::core::PointerProxy &transformer) const
-      -> void override {
-    auto minimum = transformer.value().at("minimum");
+  auto transform(sourcemeta::core::JSON &schema) const -> void override {
+    auto minimum = schema.at("minimum");
     auto options = sourcemeta::core::JSON::make_object();
     options.assign("minimum", std::move(minimum));
     options.assign("multiplier", sourcemeta::core::JSON{1});
-    make_encoding(transformer, "FLOOR_MULTIPLE_ENUM_VARINT", options);
+    make_encoding(schema, "FLOOR_MULTIPLE_ENUM_VARINT", options);
   }
 };

src/compiler/mapper/integer_lower_bound_multiplier.h

@@ -19,13 +19,12 @@ class IntegerLowerBoundMultiplier final
            schema.defines("multipleOf") && schema.at("multipleOf").is_integer();
   }
 
-  auto transform(sourcemeta::core::PointerProxy &transformer) const
-      -> void override {
-    auto minimum = transformer.value().at("minimum");
-    auto multiplier = transformer.value().at("multipleOf");
+  auto transform(sourcemeta::core::JSON &schema) const -> void override {
+    auto minimum = schema.at("minimum");
+    auto multiplier = schema.at("multipleOf");
     auto options = sourcemeta::core::JSON::make_object();
     options.assign("minimum", std::move(minimum));
     options.assign("multiplier", std::move(multiplier));
-    make_encoding(transformer, "FLOOR_MULTIPLE_ENUM_VARINT", options);
+    make_encoding(schema, "FLOOR_MULTIPLE_ENUM_VARINT", options);
   }
 };

src/compiler/mapper/integer_unbound.h

@@ -17,10 +17,9 @@ class IntegerUnbound final : public sourcemeta::core::SchemaTransformRule {
            !schema.defines("multipleOf");
   }
 
-  auto transform(sourcemeta::core::PointerProxy &transformer) const
-      -> void override {
+  auto transform(sourcemeta::core::JSON &schema) const -> void override {
     auto options = sourcemeta::core::JSON::make_object();
     options.assign("multiplier", sourcemeta::core::JSON{1});
-    make_encoding(transformer, "ARBITRARY_MULTIPLE_ZIGZAG_VARINT", options);
+    make_encoding(schema, "ARBITRARY_MULTIPLE_ZIGZAG_VARINT", options);
   }
 };

src/compiler/mapper/integer_unbound_multiplier.h

@@ -19,11 +19,10 @@ class IntegerUnboundMultiplier final
            schema.defines("multipleOf") && schema.at("multipleOf").is_integer();
   }
 
-  auto transform(sourcemeta::core::PointerProxy &transformer) const
-      -> void override {
-    auto multiplier = transformer.value().at("multipleOf");
+  auto transform(sourcemeta::core::JSON &schema) const -> void override {
+    auto multiplier = schema.at("multipleOf");
     auto options = sourcemeta::core::JSON::make_object();
     options.assign("multiplier", std::move(multiplier));
-    make_encoding(transformer, "ARBITRARY_MULTIPLE_ZIGZAG_VARINT", options);
+    make_encoding(schema, "ARBITRARY_MULTIPLE_ZIGZAG_VARINT", options);
   }
 };

src/compiler/mapper/integer_upper_bound.h

@@ -17,12 +17,11 @@ class IntegerUpperBound final : public sourcemeta::core::SchemaTransformRule {
            !schema.defines("multipleOf");
   }
 
-  auto transform(sourcemeta::core::PointerProxy &transformer) const
-      -> void override {
-    auto maximum = transformer.value().at("maximum");
+  auto transform(sourcemeta::core::JSON &schema) const -> void override {
+    auto maximum = schema.at("maximum");
     auto options = sourcemeta::core::JSON::make_object();
     options.assign("maximum", std::move(maximum));
     options.assign("multiplier", sourcemeta::core::JSON{1});
-    make_encoding(transformer, "ROOF_MULTIPLE_MIRROR_ENUM_VARINT", options);
+    make_encoding(schema, "ROOF_MULTIPLE_MIRROR_ENUM_VARINT", options);
   }
 };

src/compiler/mapper/integer_upper_bound_multiplier.h

@@ -19,13 +19,12 @@ class IntegerUpperBoundMultiplier final
            schema.defines("multipleOf") && schema.at("multipleOf").is_integer();
   }
 
-  auto transform(sourcemeta::core::PointerProxy &transformer) const
-      -> void override {
-    auto maximum = transformer.value().at("maximum");
-    auto multiplier = transformer.value().at("multipleOf");
+  auto transform(sourcemeta::core::JSON &schema) const -> void override {
+    auto maximum = schema.at("maximum");
+    auto multiplier = schema.at("multipleOf");
     auto options = sourcemeta::core::JSON::make_object();
     options.assign("maximum", std::move(maximum));
     options.assign("multiplier", std::move(multiplier));
-    make_encoding(transformer, "ROOF_MULTIPLE_MIRROR_ENUM_VARINT", options);
+    make_encoding(schema, "ROOF_MULTIPLE_MIRROR_ENUM_VARINT", options);
   }
 };

src/compiler/mapper/number_arbitrary.h

@@ -14,9 +14,8 @@ class NumberArbitrary final : public sourcemeta::core::SchemaTransformRule {
            schema.defines("type") && schema.at("type").to_string() == "number";
   }
 
-  auto transform(sourcemeta::core::PointerProxy &transformer) const
-      -> void override {
-    make_encoding(transformer, "DOUBLE_VARINT_TUPLE",
+  auto transform(sourcemeta::core::JSON &schema) const -> void override {
+    make_encoding(schema, "DOUBLE_VARINT_TUPLE",
                   sourcemeta::core::JSON::make_object());
   }
 };

test/e2e/circleciblank/schema-less/canonical.json

@@ -1,15 +1,10 @@
 {
   "anyOf": [
     {
-      "enum": [
-        null
-      ]
+      "enum": [ null ]
     },
     {
-      "enum": [
-        false,
-        true
-      ]
+      "enum": [ false, true ]
     },
     {
       "type": "object",

test/e2e/circlecimatrix/schema-less/canonical.json

@@ -1,15 +1,10 @@
 {
   "anyOf": [
     {
-      "enum": [
-        null
-      ]
+      "enum": [ null ]
     },
     {
-      "enum": [
-        false,
-        true
-      ]
+      "enum": [ false, true ]
     },
     {
       "type": "object",

test/e2e/commitlint/schema-less/canonical.json

@@ -1,15 +1,10 @@
 {
   "anyOf": [
     {
-      "enum": [
-        null
-      ]
+      "enum": [ null ]
     },
     {
-      "enum": [
-        false,
-        true
-      ]
+      "enum": [ false, true ]
     },
     {
       "type": "object",

test/e2e/commitlintbasic/schema-less/canonical.json

@@ -1,15 +1,10 @@
 {
   "anyOf": [
     {
-      "enum": [
-        null
-      ]
+      "enum": [ null ]
     },
     {
-      "enum": [
-        false,
-        true
-      ]
+      "enum": [ false, true ]
     },
     {
       "type": "object",

test/e2e/epr/schema-less/canonical.json

@@ -1,15 +1,10 @@
 {
   "anyOf": [
     {
-      "enum": [
-        null
-      ]
+      "enum": [ null ]
     },
     {
-      "enum": [
-        false,
-        true
-      ]
+      "enum": [ false, true ]
     },
     {
       "type": "object",

test/e2e/eslintrc/schema-less/canonical.json

@@ -1,15 +1,10 @@
 {
   "anyOf": [
     {
-      "enum": [
-        null
-      ]
+      "enum": [ null ]
     },
     {
-      "enum": [
-        false,
-        true
-      ]
+      "enum": [ false, true ]
     },
     {
       "type": "object",