Implement a new AnnotationWhenArraySizeEqual compiler step (#1097)

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

src/jsonschema/compile_describe.cc

@@ -279,15 +279,6 @@ struct DescribeVisitor {
       return message.str();
     }
 
-    if (this->keyword == "prefixItems" && this->annotation.is_boolean() &&
-        this->annotation.to_boolean()) {
-      assert(this->target.is_array());
-      std::ostringstream message;
-      message << "Every item of the array value validated against the given "
-                 "positional subschemas";
-      return message.str();
-    }
-
     if ((this->keyword == "prefixItems" || this->keyword == "items") &&
         this->annotation.is_integer()) {
       assert(this->target.is_array());
@@ -477,6 +468,29 @@ struct DescribeVisitor {
     return message.str();
   }
 
+  auto operator()(const SchemaCompilerAnnotationWhenArraySizeEqual &) const
+      -> std::string {
+    if (this->keyword == "items" && this->annotation.is_boolean() &&
+        this->annotation.to_boolean()) {
+      assert(this->target.is_array());
+      std::ostringstream message;
+      message << "At least one item of the array value successfully validated "
+                 "against the given subschema";
+      return message.str();
+    }
+
+    if (this->keyword == "prefixItems" && this->annotation.is_boolean() &&
+        this->annotation.to_boolean()) {
+      assert(this->target.is_array());
+      std::ostringstream message;
+      message << "Every item of the array value validated against the given "
+                 "positional subschemas";
+      return message.str();
+    }
+
+    return unknown();
+  }
+
   auto
   operator()(const SchemaCompilerAnnotationToParent &) const -> std::string {
     if (this->keyword == "unevaluatedItems" && this->annotation.is_boolean() &&

src/jsonschema/compile_evaluate.cc

@@ -921,6 +921,27 @@ auto evaluate_step(
     context.pop(annotation);
     SOURCEMETA_TRACE_END(trace_id, "SchemaCompilerAnnotationEmit");
     return result;
+  } else if (std::holds_alternative<SchemaCompilerAnnotationWhenArraySizeEqual>(
+                 step)) {
+    SOURCEMETA_TRACE_START(trace_id,
+                           "SchemaCompilerAnnotationWhenArraySizeEqual");
+    const auto &annotation{
+        std::get<SchemaCompilerAnnotationWhenArraySizeEqual>(step)};
+    context.push(annotation);
+    const auto &target{context.resolve_target(instance)};
+    EVALUATE_IMPLICIT_PRECONDITION(
+        "SchemaCompilerAnnotationWhenArraySizeEqual", annotation,
+        target.is_array() && target.size() == annotation.value.first);
+    // Annotations never fail
+    result = true;
+    const auto &current_instance_location{context.instance_location()};
+    const auto value{
+        context.annotate(current_instance_location, annotation.value.second)};
+    CALLBACK_ANNOTATION(value, annotation, current_instance_location);
+    context.pop(annotation);
+    SOURCEMETA_TRACE_END(trace_id,
+                         "SchemaCompilerAnnotationWhenArraySizeEqual");
+    return result;
   } else if (std::holds_alternative<SchemaCompilerAnnotationToParent>(step)) {
     SOURCEMETA_TRACE_START(trace_id, "SchemaCompilerAnnotationToParent");
     const auto &annotation{std::get<SchemaCompilerAnnotationToParent>(step)};

src/jsonschema/compile_json.cc

@@ -102,26 +102,34 @@ auto value_to_json(const T &value) -> sourcemeta::jsontoolkit::JSON {
       map.assign(string, std::move(dependencies));
     }
 
-    result.assign("map", std::move(map));
+    result.assign("value", std::move(map));
     return result;
   } else if constexpr (std::is_same_v<
                            SchemaCompilerValueItemsAnnotationKeywords, T>) {
     result.assign("type", JSON{"items-annotation-keywords"});
-    JSON values{JSON::make_object()};
-    result.assign("index", JSON{value.index});
+    JSON data{JSON::make_object()};
+    data.assign("index", JSON{value.index});
 
     JSON mask{JSON::make_array()};
     for (const auto &keyword : value.mask) {
       mask.push_back(JSON{keyword});
     }
-    result.assign("mask", std::move(mask));
+    data.assign("mask", std::move(mask));
 
     JSON filter{JSON::make_array()};
     for (const auto &keyword : value.filter) {
       filter.push_back(JSON{keyword});
     }
-    result.assign("filter", std::move(filter));
+    data.assign("filter", std::move(filter));
 
+    result.assign("value", std::move(data));
+    return result;
+  } else if constexpr (std::is_same_v<SchemaCompilerValueIndexedJSON, T>) {
+    result.assign("type", JSON{"indexed-json"});
+    JSON data{JSON::make_object()};
+    data.assign("index", JSON{value.first});
+    data.assign("value", value.second);
+    result.assign("value", std::move(data));
     return result;
   } else if constexpr (std::is_same_v<SchemaCompilerValueStringType, T>) {
     result.assign("type", JSON{"string-type"});
@@ -211,6 +219,8 @@ struct StepVisitor {
   HANDLE_STEP("assertion", "equals-any", SchemaCompilerAssertionEqualsAny)
   HANDLE_STEP("assertion", "size-equal", SchemaCompilerAssertionSizeEqual)
   HANDLE_STEP("annotation", "emit", SchemaCompilerAnnotationEmit)
+  HANDLE_STEP("annotation", "when-array-size-equal",
+              SchemaCompilerAnnotationWhenArraySizeEqual)
   HANDLE_STEP("annotation", "to-parent", SchemaCompilerAnnotationToParent)
   HANDLE_STEP("annotation", "basename-to-parent",
               SchemaCompilerAnnotationBasenameToParent)

src/jsonschema/default_compiler_draft4.h

@@ -629,11 +629,10 @@ auto compiler_draft4_applicator_items_array(
     // The first entry
     if (cursor == items_size) {
       if (annotate) {
-        subchildren.push_back(make<SchemaCompilerAnnotationEmit>(
-            true, context, schema_context, relative_dynamic_context, JSON{true},
-            {make<SchemaCompilerAssertionSizeEqual>(
-                false, context, schema_context, relative_dynamic_context,
-                SchemaCompilerValueUnsignedInteger{cursor}, {})}));
+        subchildren.push_back(make<SchemaCompilerAnnotationWhenArraySizeEqual>(
+            true, context, schema_context, relative_dynamic_context,
+            SchemaCompilerValueIndexedJSON{cursor, JSON{true}},
+            SchemaCompilerTemplate{}));
         subchildren.push_back(make<SchemaCompilerAnnotationEmit>(
             true, context, schema_context, relative_dynamic_context,
             JSON{cursor - 1},

src/jsonschema/include/sourcemeta/jsontoolkit/jsonschema_compile.h

@@ -96,6 +96,11 @@ struct SchemaCompilerValueItemsAnnotationKeywords {
 using SchemaCompilerValueStringMap =
     std::map<SchemaCompilerValueString, SchemaCompilerValueStrings>;
 
+/// @ingroup jsonschema
+/// Represents a compiler step JSON value accompanied with an index
+using SchemaCompilerValueIndexedJSON =
+    std::pair<SchemaCompilerValueUnsignedInteger, JSON>;
+
 /// @ingroup jsonschema
 /// Represents a compiler assertion step that always fails
 struct SchemaCompilerAssertionFail;
@@ -207,6 +212,11 @@ struct SchemaCompilerAssertionSizeEqual;
 /// Represents a compiler step that emits an annotation
 struct SchemaCompilerAnnotationEmit;
 
+/// @ingroup jsonschema
+/// Represents a compiler step that emits an annotation when the size of the
+/// array instance is equal to the given size
+struct SchemaCompilerAnnotationWhenArraySizeEqual;
+
 /// @ingroup jsonschema
 /// Represents a compiler step that emits an annotation to the parent
 struct SchemaCompilerAnnotationToParent;
@@ -345,9 +355,9 @@ using SchemaCompilerTemplate = std::vector<std::variant<
     SchemaCompilerAssertionGreater, SchemaCompilerAssertionLess,
     SchemaCompilerAssertionUnique, SchemaCompilerAssertionDivisible,
     SchemaCompilerAssertionStringType, SchemaCompilerAssertionSizeEqual,
-    SchemaCompilerAnnotationEmit, SchemaCompilerAnnotationToParent,
-    SchemaCompilerAnnotationBasenameToParent, SchemaCompilerLogicalOr,
-    SchemaCompilerLogicalAnd, SchemaCompilerLogicalXor,
+    SchemaCompilerAnnotationEmit, SchemaCompilerAnnotationWhenArraySizeEqual,
+    SchemaCompilerAnnotationToParent, SchemaCompilerAnnotationBasenameToParent,
+    SchemaCompilerLogicalOr, SchemaCompilerLogicalAnd, SchemaCompilerLogicalXor,
     SchemaCompilerLogicalTryMark, SchemaCompilerLogicalNot,
     SchemaCompilerLogicalWhenType, SchemaCompilerLogicalWhenDefines,
     SchemaCompilerLogicalWhenAdjacentUnmarked,
@@ -412,6 +422,8 @@ DEFINE_STEP_WITH_VALUE(Assertion, Divisible, SchemaCompilerValueJSON)
 DEFINE_STEP_WITH_VALUE(Assertion, StringType, SchemaCompilerValueStringType)
 DEFINE_STEP_WITH_VALUE(Assertion, SizeEqual, SchemaCompilerValueUnsignedInteger)
 DEFINE_STEP_WITH_VALUE(Annotation, Emit, SchemaCompilerValueJSON)
+DEFINE_STEP_WITH_VALUE(Annotation, WhenArraySizeEqual,
+                       SchemaCompilerValueIndexedJSON)
 DEFINE_STEP_WITH_VALUE(Annotation, ToParent, SchemaCompilerValueJSON)
 DEFINE_STEP_WITH_VALUE(Annotation, BasenameToParent, SchemaCompilerValueNone)
 DEFINE_STEP_APPLICATOR(Logical, Or, SchemaCompilerValueBoolean)

test/jsonschema/jsonschema_test_utils.h

@@ -276,6 +276,12 @@
                  std::get<3>(trace_pre.at(index)))) {                          \
     EVALUATE_TRACE_PRE(index, AnnotationToParent, evaluate_path,               \
                        keyword_location, instance_location);                   \
+  } else if (std::holds_alternative<                                           \
+                 sourcemeta::jsontoolkit::                                     \
+                     SchemaCompilerAnnotationWhenArraySizeEqual>(              \
+                 std::get<3>(trace_pre.at(index)))) {                          \
+    EVALUATE_TRACE_PRE(index, AnnotationWhenArraySizeEqual, evaluate_path,     \
+                       keyword_location, instance_location);                   \
   } else {                                                                     \
     EVALUATE_TRACE_PRE(index, AnnotationEmit, evaluate_path, keyword_location, \
                        instance_location);                                     \
@@ -296,6 +302,12 @@
                  std::get<3>(trace_post.at(index)))) {                         \
     EVALUATE_TRACE_POST(index, AnnotationToParent, evaluate_path,              \
                         keyword_location, instance_location);                  \
+  } else if (std::holds_alternative<                                           \
+                 sourcemeta::jsontoolkit::                                     \
+                     SchemaCompilerAnnotationWhenArraySizeEqual>(              \
+                 std::get<3>(trace_post.at(index)))) {                         \
+    EVALUATE_TRACE_POST(index, AnnotationWhenArraySizeEqual, evaluate_path,    \
+                        keyword_location, instance_location);                  \
   } else {                                                                     \
     EVALUATE_TRACE_POST(index, AnnotationEmit, evaluate_path,                  \
                         keyword_location, instance_location);                  \