Support the Flag and Basic standard output formats (#471)

See: sourcemeta/jsonschema#213
See: sourcemeta/jsonschema#58
Signed-off-by: Juan Cruz Viotti <[email protected]>

Author: jviotti

README.markdown

@@ -41,8 +41,10 @@ Features
 - **Compliance:** Blaze achieves a 100% compliance score in the official
   [Bowtie](https://bowtie.report/#/implementations/cpp-blaze) benchmark, while
   popular validators like [AJV](https://bowtie.report/#/implementations/js-ajv)
-  only achieve an average 85% compliance. Furthermore, Blaze is built and
-  maintained by a [JSON Schema TSC member](https://www.jviotti.com)
+  only achieve an average 85% compliance. It also supports the [Standard
+  Output](https://json-schema.org/draft/2020-12/json-schema-core#name-output-formatting)
+  format (Flag, and Basic). Furthermore, Blaze is built and maintained by a
+  [JSON Schema TSC member](https://www.jviotti.com)
 
 - **Extensibility:** Blaze supports the implementation of custom vocabularies
   of arbitrary complexity, and the ability to setup custom resolution of

src/compiler/CMakeLists.txt

@@ -3,8 +3,10 @@ sourcemeta_library(NAMESPACE sourcemeta PROJECT blaze NAME compiler
   PRIVATE_HEADERS error.h output.h unevaluated.h
   SOURCES
     compile.cc compile_describe.cc compile_json.cc
-    compile_output_simple.cc compile_output_trace.cc
     compile_helpers.h default_compiler.cc unevaluated.cc
+    compile_output_simple.cc
+    compile_output_trace.cc
+    compile_output_standard.cc
     default_compiler_2020_12.h
     default_compiler_2019_09.h
     default_compiler_draft7.h

src/compiler/compile_output_standard.cc

@@ -0,0 +1,68 @@
+#include <sourcemeta/blaze/compiler.h>
+
+#include <cassert>    // assert
+#include <functional> // std::ref
+
+namespace sourcemeta::blaze {
+
+auto standard(Evaluator &evaluator, const Template &schema,
+              const sourcemeta::core::JSON &instance,
+              const StandardOutput format) -> sourcemeta::core::JSON {
+  // We avoid a callback for this specific case for performance reasons
+  if (format == StandardOutput::Flag) {
+    auto result{sourcemeta::core::JSON::make_object()};
+    const auto valid{evaluator.validate(schema, instance)};
+    result.assign("valid", sourcemeta::core::JSON{valid});
+    return result;
+  } else {
+    assert(format == StandardOutput::Basic);
+    SimpleOutput output{instance};
+    const auto valid{evaluator.validate(schema, instance, std::ref(output))};
+
+    if (valid) {
+      auto result{sourcemeta::core::JSON::make_object()};
+      result.assign("valid", sourcemeta::core::JSON{valid});
+      auto annotations{sourcemeta::core::JSON::make_array()};
+      for (const auto &annotation : output.annotations()) {
+        auto unit{sourcemeta::core::JSON::make_object()};
+        unit.assign(
+            "keywordLocation",
+            sourcemeta::core::to_json(annotation.first.evaluate_path).value());
+        unit.assign("absoluteKeywordLocation",
+                    sourcemeta::core::JSON{annotation.first.schema_location});
+        unit.assign("instanceLocation", sourcemeta::core::to_json(
+                                            annotation.first.instance_location)
+                                            .value());
+        unit.assign("annotation", sourcemeta::core::to_json(annotation.second));
+        annotations.push_back(std::move(unit));
+      }
+
+      if (!annotations.empty()) {
+        result.assign("annotations", std::move(annotations));
+      }
+
+      return result;
+    } else {
+      auto result{sourcemeta::core::JSON::make_object()};
+      result.assign("valid", sourcemeta::core::JSON{valid});
+      auto errors{sourcemeta::core::JSON::make_array()};
+      for (const auto &entry : output) {
+        auto unit{sourcemeta::core::JSON::make_object()};
+        unit.assign("keywordLocation",
+                    sourcemeta::core::to_json(entry.evaluate_path).value());
+        unit.assign("absoluteKeywordLocation",
+                    sourcemeta::core::JSON{entry.schema_location});
+        unit.assign("instanceLocation",
+                    sourcemeta::core::to_json(entry.instance_location).value());
+        unit.assign("error", sourcemeta::core::JSON{entry.message});
+        errors.push_back(std::move(unit));
+      }
+
+      assert(!errors.empty());
+      result.assign("errors", std::move(errors));
+      return result;
+    }
+  }
+}
+
+} // namespace sourcemeta::blaze

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

@@ -264,6 +264,71 @@ describe(const bool valid, const Instruction &step,
          const sourcemeta::core::JSON &instance,
          const sourcemeta::core::JSON &annotation) -> std::string;
 
+/// @ingroup compiler
+/// Represents standard output formats
+/// See
+/// https://json-schema.org/draft/2020-12/json-schema-core#name-output-structure
+/// See
+/// https://json-schema.org/draft/2019-09/draft-handrews-json-schema-02#rfc.section.10
+enum class StandardOutput {
+  Flag,
+  Basic
+  // TODO: Implement the "detailed" and "verbose" output formats
+};
+
+// TODO: Integrate with
+// https://github.com/json-schema-org/JSON-Schema-Test-Suite/tree/main/output-tests
+
+/// @ingroup compiler
+/// Perform JSON Schema evaluation using Standard Output formats. For example:
+///
+/// ```cpp
+/// #include <sourcemeta/blaze/evaluator.h>
+/// #include <sourcemeta/blaze/compiler.h>
+///
+/// #include <sourcemeta/core/json.h>
+/// #include <sourcemeta/core/jsonschema.h>
+///
+/// #include <cassert>
+/// #include <iostream>
+///
+/// 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::core::default_schema_compiler)};
+///
+/// const sourcemeta::core::JSON instance{"foo bar"};
+///
+/// sourcemeta::blaze::Evaluator evaluator;
+///
+/// const auto result{sourcemeta::blaze::standard(
+///   evaluator, schema_template, instance,
+///   sourcemeta::blaze::StandardOutput::Basic)};
+///
+/// assert(result.is_object());
+/// assert(result.defines("valid"));
+/// assert(result.at("valid").is_boolean());
+/// assert(result.at("valid").to_boolean());
+///
+/// sourcemeta::core::prettify(result,
+///   std::cout, sourcemeta::blaze::standard_output_compare);
+/// std::cout << "\n";
+/// ```
+///
+/// Note that this output format is not a class like the others
+/// in order to have additional control over how and whether to
+/// pass a callback to the evaluator instance.
+auto SOURCEMETA_BLAZE_COMPILER_EXPORT
+standard(Evaluator &evaluator, const Template &schema,
+         const sourcemeta::core::JSON &instance, const StandardOutput format)
+    -> sourcemeta::core::JSON;
+
 } // namespace sourcemeta::blaze
 
 #endif

test/compiler/CMakeLists.txt

@@ -3,6 +3,8 @@ sourcemeta_googletest(NAMESPACE sourcemeta PROJECT blaze NAME compiler
   SOURCES
     compiler_output_simple_test.cc
     compiler_output_trace_test.cc
+    compiler_output_standard_flag_test.cc
+    compiler_output_standard_basic_test.cc
     compiler_unevaluated_2019_09_test.cc
     compiler_unevaluated_2020_12_test.cc
     compiler_json_test.cc