Support converting Instruction to JSON (#453)

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

Author: jviotti

DEPENDENCIES

@@ -1,3 +1,3 @@
 vendorpull https://github.com/sourcemeta/vendorpull dea311b5bfb53b6926a4140267959ae334d3ecf4
-core https://github.com/sourcemeta/core 435c78ca85510b428840c3ca06be7e9eeb838cd5
+core https://github.com/sourcemeta/core 2aab6820e4b4ff7062954c7ee4f55aea04112496
 jsonschema-test-suite https://github.com/json-schema-org/JSON-Schema-Test-Suite 48461fc3568972801b40eaccc428a31bce338f6e

src/compiler/CMakeLists.txt

@@ -2,7 +2,7 @@ sourcemeta_library(NAMESPACE sourcemeta PROJECT blaze NAME compiler
   FOLDER "Blaze/Compiler"
   PRIVATE_HEADERS error.h output.h unevaluated.h
   SOURCES
-    compile.cc compile_describe.cc
+    compile.cc compile_describe.cc compile_json.cc
     compile_output_simple.cc compile_output_trace.cc
     compile_helpers.h default_compiler.cc unevaluated.cc
     default_compiler_2020_12.h

src/compiler/compile_json.cc

@@ -0,0 +1,72 @@
+#include <sourcemeta/blaze/compiler.h>
+
+#include <variant> // std::visit
+
+namespace sourcemeta::core {
+template <typename T>
+  requires std::is_same_v<T, sourcemeta::blaze::ValueNone>
+auto to_json(const T &) -> JSON {
+  return JSON{nullptr};
+}
+template <typename T>
+  requires std::is_same_v<T, typename sourcemeta::blaze::ValueRegex::first_type>
+auto to_json(const T &) -> JSON {
+  return JSON{nullptr};
+}
+template <typename T>
+  requires std::is_same_v<T, sourcemeta::blaze::ValueRegex>
+auto to_json(const T &value) -> JSON {
+  return JSON{value.second};
+}
+} // namespace sourcemeta::core
+
+namespace sourcemeta::blaze {
+
+auto to_json(const Instruction &instruction) -> sourcemeta::core::JSON {
+  auto result{sourcemeta::core::JSON::make_object()};
+  // We use single characters to save space, as this serialised format
+  // is not meant to be human-readable anyway
+  result.assign("t", sourcemeta::core::to_json(instruction.type));
+  result.assign(
+      "s", sourcemeta::core::to_json(instruction.relative_schema_location));
+  result.assign(
+      "i", sourcemeta::core::to_json(instruction.relative_instance_location));
+  result.assign("k", sourcemeta::core::to_json(instruction.keyword_location));
+  result.assign("r", sourcemeta::core::to_json(instruction.schema_resource));
+
+  auto value{sourcemeta::core::JSON::make_object()};
+  value.assign("t", sourcemeta::core::to_json(instruction.value.index()));
+  value.assign("v", std::visit(
+                        [](const auto &variant) {
+                          return sourcemeta::core::to_json(variant);
+                        },
+                        instruction.value));
+  result.assign("v", std::move(value));
+
+  assert(result.at("v").is_object());
+  assert(result.at("v").size() == 2);
+  assert(result.at("v").defines("t"));
+  assert(result.at("v").defines("v"));
+  assert(result.at("v").at("t").is_integer());
+
+  auto children_json{sourcemeta::core::JSON::make_array()};
+  result.assign("c", sourcemeta::core::to_json(instruction.children,
+                                               [](const auto &subinstruction) {
+                                                 return to_json(subinstruction);
+                                               }));
+  return result;
+}
+
+auto to_json(const Template &schema_template) -> sourcemeta::core::JSON {
+  auto result{sourcemeta::core::JSON::make_object()};
+  result.assign("dynamic", sourcemeta::core::JSON{schema_template.dynamic});
+  result.assign("track", sourcemeta::core::JSON{schema_template.track});
+  result.assign("instructions",
+                sourcemeta::core::to_json(schema_template.instructions,
+                                          [](const auto &instruction) {
+                                            return to_json(instruction);
+                                          }));
+  return result;
+}
+
+} // namespace sourcemeta::blaze

src/compiler/include/sourcemeta/blaze/compiler.h

@@ -185,6 +185,16 @@ compile(const Context &context, const SchemaContext &schema_context,
             sourcemeta::core::empty_pointer,
         const std::optional<std::string> &uri = std::nullopt) -> Instructions;
 
+/// @ingroup compiler
+/// Serialise an instruction as JSON
+auto SOURCEMETA_BLAZE_COMPILER_EXPORT to_json(const Instruction &instruction)
+    -> sourcemeta::core::JSON;
+
+/// @ingroup compiler
+/// Serialise a template as JSON
+auto SOURCEMETA_BLAZE_COMPILER_EXPORT to_json(const Template &schema_template)
+    -> sourcemeta::core::JSON;
+
 } // namespace sourcemeta::blaze
 
 #endif

src/evaluator/include/sourcemeta/blaze/evaluator_string_set.h

@@ -45,6 +45,12 @@ class SOURCEMETA_BLAZE_EVALUATOR_EXPORT StringSet {
   inline auto cbegin() const -> const_iterator { return this->data.cbegin(); }
   inline auto cend() const -> const_iterator { return this->data.cend(); }
 
+  auto to_json() const -> sourcemeta::core::JSON {
+    return sourcemeta::core::to_json(this->data, [](const auto &item) {
+      return sourcemeta::core::to_json(item.first);
+    });
+  }
+
 private:
 // Exporting symbols that depends on the standard C++ library is considered
 // safe.

test/compiler/CMakeLists.txt

@@ -5,6 +5,7 @@ sourcemeta_googletest(NAMESPACE sourcemeta PROJECT blaze NAME compiler
     compiler_output_trace_test.cc
     compiler_unevaluated_2019_09_test.cc
     compiler_unevaluated_2020_12_test.cc
+    compiler_json_test.cc
     compiler_test_utils.h)
 
 target_link_libraries(sourcemeta_blaze_compiler_unit

test/compiler/compiler_json_test.cc

@@ -0,0 +1,104 @@
+#include <gtest/gtest.h>
+
+#include <sourcemeta/blaze/compiler.h>
+
+// TODO: Eventually test parsing the JSON back and asserting that it equals the
+// original template, using a helper macro to define each test
+
+TEST(Compiler_JSON, example_1) {
+  const sourcemeta::core::JSON schema{sourcemeta::core::parse_json(R"JSON({
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "type": "string"
+  })JSON")};
+
+  const auto schema_template{sourcemeta::blaze::compile(
+      schema, sourcemeta::core::schema_official_walker,
+      sourcemeta::core::schema_official_resolver,
+      sourcemeta::blaze::default_schema_compiler)};
+
+  const auto result{sourcemeta::blaze::to_json(schema_template)};
+
+  const sourcemeta::core::JSON expected{sourcemeta::core::parse_json(R"JSON({
+    "dynamic": false,
+    "track": false,
+    "instructions": [
+      {
+        "t": 11,
+        "s": "/type",
+        "i": "",
+        "k": "#/type",
+        "r": 0,
+        "v": {
+          "t": 8,
+          "v": 4
+        },
+        "c": []
+      }
+    ]
+  })JSON")};
+
+  EXPECT_EQ(result, expected);
+}
+
+TEST(Compiler_JSON, example_2) {
+  const sourcemeta::core::JSON schema{sourcemeta::core::parse_json(R"JSON({
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "additionalProperties": {
+      "type": [ "number", "string" ],
+      "multipleOf": 2
+    }
+  })JSON")};
+
+  const auto schema_template{sourcemeta::blaze::compile(
+      schema, sourcemeta::core::schema_official_walker,
+      sourcemeta::core::schema_official_resolver,
+      sourcemeta::blaze::default_schema_compiler)};
+
+  const auto result{sourcemeta::blaze::to_json(schema_template)};
+
+  const sourcemeta::core::JSON expected{sourcemeta::core::parse_json(R"JSON({
+    "dynamic": false,
+    "track": false,
+    "instructions": [
+      {
+        "t": 61,
+        "s": "/additionalProperties",
+        "i": "",
+        "k": "#/additionalProperties",
+        "r": 0,
+        "v": {
+          "t": 0,
+          "v": null
+        },
+        "c": [
+          {
+            "t": 34,
+            "s": "/multipleOf",
+            "i": "",
+            "k": "#/additionalProperties/multipleOf",
+            "r": 0,
+            "v": {
+              "t": 1,
+              "v": 2
+            },
+            "c": []
+          },
+          {
+            "t": 10,
+            "s": "/type",
+            "i": "",
+            "k": "#/additionalProperties/type",
+            "r": 0,
+            "v": {
+              "t": 7,
+              "v": [ 2, 3, 4 ]
+            },
+            "c": []
+          }
+        ]
+      }
+    ]
+  })JSON")};
+
+  EXPECT_EQ(result, expected);
+}