Support annotations on TraceOutput (#400)

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

Author: jviotti

src/compiler/compile_output_trace.cc

@@ -33,23 +33,32 @@ auto TraceOutput::operator()(
     const EvaluationType type, const bool result, const Instruction &step,
     const sourcemeta::core::WeakPointer &evaluate_path,
     const sourcemeta::core::WeakPointer &instance_location,
-    const sourcemeta::core::JSON &) -> void {
+    const sourcemeta::core::JSON &annotation) -> void {
 
   const auto short_step_name{step_name(step)};
   auto effective_evaluate_path{evaluate_path.resolve_from(this->base_)};
 
-  if (type == EvaluationType::Pre) {
+  if (is_annotation(step.type)) {
+    if (type == EvaluationType::Pre) {
+      return;
+    } else {
+      this->output.push_back({EntryType::Annotation, short_step_name,
+                              instance_location,
+                              std::move(effective_evaluate_path),
+                              step.keyword_location, annotation});
+    }
+  } else if (type == EvaluationType::Pre) {
     this->output.push_back({EntryType::Push, short_step_name, instance_location,
                             std::move(effective_evaluate_path),
-                            step.keyword_location});
+                            step.keyword_location, std::nullopt});
   } else if (result) {
     this->output.push_back({EntryType::Pass, short_step_name, instance_location,
                             std::move(effective_evaluate_path),
-                            step.keyword_location});
+                            step.keyword_location, std::nullopt});
   } else {
     this->output.push_back({EntryType::Fail, short_step_name, instance_location,
                             std::move(effective_evaluate_path),
-                            step.keyword_location});
+                            step.keyword_location, std::nullopt});
   }
 }
 

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

@@ -177,6 +177,7 @@ class SOURCEMETA_BLAZE_COMPILER_EXPORT TraceOutput {
     const sourcemeta::core::WeakPointer instance_location;
     const sourcemeta::core::WeakPointer evaluate_path;
     const std::string keyword_location;
+    const std::optional<sourcemeta::core::JSON> annotation;
   };
 
   auto operator()(const EvaluationType type, const bool result,

test/compiler/compiler_output_trace_test.cc

@@ -8,7 +8,7 @@
 
 #define EXPECT_OUTPUT(traces, index, expected_type, expected_name,             \
                       expected_instance_location, expected_evaluate_path,      \
-                      expected_keyword_location)                               \
+                      expected_keyword_location, expected_annotation)          \
   EXPECT_TRUE(traces.size() > index);                                          \
   EXPECT_EQ(traces.at((index)).type,                                           \
             sourcemeta::blaze::TraceOutput::EntryType::expected_type);         \
@@ -17,7 +17,16 @@
             expected_instance_location);                                       \
   EXPECT_EQ(sourcemeta::core::to_string(traces.at((index)).evaluate_path),     \
             expected_evaluate_path);                                           \
-  EXPECT_EQ(traces.at((index)).keyword_location, (expected_keyword_location));
+  EXPECT_EQ(traces.at((index)).keyword_location, (expected_keyword_location)); \
+  if (std::optional<sourcemeta::core::JSON>{expected_annotation}               \
+          .has_value()) {                                                      \
+    EXPECT_TRUE(traces.at((index)).annotation.has_value());                    \
+    EXPECT_EQ(                                                                 \
+        traces.at((index)).annotation.value(),                                 \
+        std::optional<sourcemeta::core::JSON>{expected_annotation}.value());   \
+  } else {                                                                     \
+    EXPECT_FALSE(traces.at((index)).annotation.has_value());                   \
+  }
 
 TEST(Compiler_output_trace, pass_1) {
   const sourcemeta::core::JSON schema{sourcemeta::core::parse_json(R"JSON({
@@ -51,13 +60,64 @@ TEST(Compiler_output_trace, pass_1) {
   EXPECT_EQ(traces.size(), 4);
 
   EXPECT_OUTPUT(traces, 0, Push, "LoopPropertiesMatchClosed", "", "/properties",
-                "#/properties");
+                "#/properties", std::nullopt);
   EXPECT_OUTPUT(traces, 1, Push, "AssertionTypeStrict", "/foo",
-                "/properties/foo/type", "#/properties/foo/type");
+                "/properties/foo/type", "#/properties/foo/type", std::nullopt);
   EXPECT_OUTPUT(traces, 2, Pass, "AssertionTypeStrict", "/foo",
-                "/properties/foo/type", "#/properties/foo/type");
+                "/properties/foo/type", "#/properties/foo/type", std::nullopt);
   EXPECT_OUTPUT(traces, 3, Pass, "LoopPropertiesMatchClosed", "", "/properties",
-                "#/properties");
+                "#/properties", std::nullopt);
+}
+
+TEST(Compiler_output_trace, pass_annotations) {
+  const sourcemeta::core::JSON schema{sourcemeta::core::parse_json(R"JSON({
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "title": "Foo Bar",
+    "additionalProperties": false,
+    "properties": {
+      "foo": true,
+      "bar": true
+    }
+  })JSON")};
+
+  const auto schema_template{sourcemeta::blaze::compile(
+      schema, sourcemeta::core::schema_official_walker,
+      sourcemeta::core::schema_official_resolver,
+      sourcemeta::blaze::default_schema_compiler,
+      sourcemeta::blaze::Mode::Exhaustive)};
+
+  const sourcemeta::core::JSON instance{sourcemeta::core::parse_json(R"JSON({
+    "foo": "bar",
+    "bar": "baz"
+  })JSON")};
+
+  sourcemeta::blaze::TraceOutput output;
+  sourcemeta::blaze::Evaluator evaluator;
+  const auto result{
+      evaluator.validate(schema_template, instance, std::ref(output))};
+
+  EXPECT_TRUE(result);
+  std::vector<sourcemeta::blaze::TraceOutput::Entry> traces{output.cbegin(),
+                                                            output.cend()};
+
+  EXPECT_EQ(traces.size(), 7);
+
+  EXPECT_OUTPUT(traces, 0, Annotation, "AnnotationEmit", "", "/title",
+                "#/title", sourcemeta::core::JSON{"Foo Bar"});
+  EXPECT_OUTPUT(traces, 1, Push, "LoopPropertiesMatch", "", "/properties",
+                "#/properties", std::nullopt);
+  EXPECT_OUTPUT(traces, 2, Annotation, "AnnotationEmit", "", "/properties",
+                "#/properties", sourcemeta::core::JSON{"foo"});
+  EXPECT_OUTPUT(traces, 3, Annotation, "AnnotationEmit", "", "/properties",
+                "#/properties", sourcemeta::core::JSON{"bar"});
+  EXPECT_OUTPUT(traces, 4, Pass, "LoopPropertiesMatch", "", "/properties",
+                "#/properties", std::nullopt);
+  EXPECT_OUTPUT(traces, 5, Push, "LoopPropertiesExcept", "",
+                "/additionalProperties", "#/additionalProperties",
+                std::nullopt);
+  EXPECT_OUTPUT(traces, 6, Pass, "LoopPropertiesExcept", "",
+                "/additionalProperties", "#/additionalProperties",
+                std::nullopt);
 }
 
 TEST(Compiler_output_trace, pass_with_matching_prefix_1) {
@@ -98,11 +158,13 @@ TEST(Compiler_output_trace, pass_with_matching_prefix_1) {
   EXPECT_EQ(traces.size(), 4);
 
   EXPECT_OUTPUT(traces, 0, Push, "LoopPropertiesMatchClosed", "", "/properties",
-                "#/$defs/helper/properties");
+                "#/$defs/helper/properties", std::nullopt);
   EXPECT_OUTPUT(traces, 1, Push, "AssertionTypeStrict", "/foo",
-                "/properties/foo/type", "#/$defs/helper/properties/foo/type");
+                "/properties/foo/type", "#/$defs/helper/properties/foo/type",
+                std::nullopt);
   EXPECT_OUTPUT(traces, 2, Pass, "AssertionTypeStrict", "/foo",
-                "/properties/foo/type", "#/$defs/helper/properties/foo/type");
+                "/properties/foo/type", "#/$defs/helper/properties/foo/type",
+                std::nullopt);
   EXPECT_OUTPUT(traces, 3, Pass, "LoopPropertiesMatchClosed", "", "/properties",
-                "#/$defs/helper/properties");
+                "#/$defs/helper/properties", std::nullopt);
 }