Extend TraceOutput to provide vocabulary information (#408)

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

Author: jviotti

contrib/trace.cc

@@ -47,7 +47,9 @@ auto main(int argc, char **argv) noexcept -> int {
   const std::filesystem::path instance_path{argv[2]};
   const auto instance{sourcemeta::core::read_json(instance_path)};
 
-  sourcemeta::blaze::TraceOutput output;
+  sourcemeta::blaze::TraceOutput output{
+      sourcemeta::core::schema_official_walker,
+      sourcemeta::core::schema_official_resolver};
   sourcemeta::blaze::Evaluator evaluator;
   const auto result{
       evaluator.validate(schema_template, instance, std::ref(output))};

src/compiler/compile_output_trace.cc

@@ -12,10 +12,39 @@ static auto step_name(const sourcemeta::blaze::Instruction &instruction)
           instruction.type)];
 }
 
+static auto try_vocabulary(
+    const std::optional<
+        std::reference_wrapper<const sourcemeta::core::SchemaFrame>> &frame,
+    const sourcemeta::core::WeakPointer &evaluate_path,
+    const sourcemeta::core::SchemaWalker &walker,
+    const sourcemeta::core::SchemaResolver &resolver,
+    const std::string &keyword_location)
+    -> std::pair<bool, std::optional<std::string>> {
+  if (!frame.has_value() || evaluate_path.empty() ||
+      !evaluate_path.back().is_property()) {
+    return {false, std::nullopt};
+  }
+
+  const auto entry{frame.value().get().traverse(keyword_location)};
+  if (!entry.has_value()) {
+    return {false, std::nullopt};
+  }
+
+  const auto vocabularies{
+      frame.value().get().vocabularies(entry.value().get(), resolver)};
+  const auto result{walker(evaluate_path.back().to_property(), vocabularies)};
+  return {true, result.vocabulary};
+}
+
 namespace sourcemeta::blaze {
 
-TraceOutput::TraceOutput(const sourcemeta::core::WeakPointer &base)
-    : base_{base} {}
+TraceOutput::TraceOutput(
+    const sourcemeta::core::SchemaWalker &walker,
+    const sourcemeta::core::SchemaResolver &resolver,
+    const sourcemeta::core::WeakPointer &base,
+    const std::optional<
+        std::reference_wrapper<const sourcemeta::core::SchemaFrame>> &frame)
+    : walker_{walker}, resolver_{resolver}, base_{base}, frame_{frame} {}
 
 auto TraceOutput::begin() const -> const_iterator {
   return this->output.begin();
@@ -38,27 +67,34 @@ auto TraceOutput::operator()(
   const auto short_step_name{step_name(step)};
   auto effective_evaluate_path{evaluate_path.resolve_from(this->base_)};
 
+  // Attempt to get vocabulary information if we can get it
+  auto vocabulary{try_vocabulary(this->frame_, evaluate_path, this->walker_,
+                                 this->resolver_, step.keyword_location)};
+
   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});
+      this->output.push_back(
+          {EntryType::Annotation, short_step_name, instance_location,
+           std::move(effective_evaluate_path), step.keyword_location,
+           annotation, std::move(vocabulary)});
     }
   } else if (type == EvaluationType::Pre) {
     this->output.push_back({EntryType::Push, short_step_name, instance_location,
                             std::move(effective_evaluate_path),
-                            step.keyword_location, std::nullopt});
+                            step.keyword_location, std::nullopt,
+                            std::move(vocabulary)});
   } else if (result) {
     this->output.push_back({EntryType::Pass, short_step_name, instance_location,
                             std::move(effective_evaluate_path),
-                            step.keyword_location, std::nullopt});
+                            step.keyword_location, std::nullopt,
+                            std::move(vocabulary)});
   } else {
     this->output.push_back({EntryType::Fail, short_step_name, instance_location,
                             std::move(effective_evaluate_path),
-                            step.keyword_location, std::nullopt});
+                            step.keyword_location, std::nullopt,
+                            std::move(vocabulary)});
   }
 }
 

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

@@ -7,10 +7,13 @@
 
 #include <sourcemeta/core/json.h>
 #include <sourcemeta/core/jsonpointer.h>
+#include <sourcemeta/core/jsonschema.h>
 
 #include <sourcemeta/blaze/evaluator.h>
 
+#include <functional>  // std::reference_wrapper
 #include <map>         // std::map
+#include <optional>    // std::optional, std::nullopt
 #include <set>         // std::set
 #include <string>      // std::string
 #include <string_view> // std::string_view
@@ -183,8 +186,14 @@ class SOURCEMETA_BLAZE_COMPILER_EXPORT SimpleOutput {
 /// ```
 class SOURCEMETA_BLAZE_COMPILER_EXPORT TraceOutput {
 public:
-  TraceOutput(const sourcemeta::core::WeakPointer &base =
-                  sourcemeta::core::empty_weak_pointer);
+  // Passing a frame of the schema is optional, but allows the output
+  // formatter to give you back additional information
+  TraceOutput(const sourcemeta::core::SchemaWalker &walker,
+              const sourcemeta::core::SchemaResolver &resolver,
+              const sourcemeta::core::WeakPointer &base =
+                  sourcemeta::core::empty_weak_pointer,
+              const std::optional<std::reference_wrapper<
+                  const sourcemeta::core::SchemaFrame>> &frame = std::nullopt);
 
   // Prevent accidental copies
   TraceOutput(const TraceOutput &) = delete;
@@ -199,6 +208,9 @@ class SOURCEMETA_BLAZE_COMPILER_EXPORT TraceOutput {
     const sourcemeta::core::WeakPointer evaluate_path;
     const std::string keyword_location;
     const std::optional<sourcemeta::core::JSON> annotation;
+    // Whether we were able to collect vocabulary information,
+    // and the vocabulary URI, if any
+    const std::pair<bool, std::optional<std::string>> vocabulary;
   };
 
   auto operator()(const EvaluationType type, const bool result,
@@ -221,7 +233,12 @@ class SOURCEMETA_BLAZE_COMPILER_EXPORT TraceOutput {
 #if defined(_MSC_VER)
 #pragma warning(disable : 4251)
 #endif
+  const sourcemeta::core::SchemaWalker walker_;
+  const sourcemeta::core::SchemaResolver resolver_;
   const sourcemeta::core::WeakPointer base_;
+  const std::optional<
+      std::reference_wrapper<const sourcemeta::core::SchemaFrame>>
+      frame_;
   container_type output;
 #if defined(_MSC_VER)
 #pragma warning(default : 4251)