mongory 0.7.2-arm64-darwin-23

data/ext/mongory_ext/mongory-core/src/matchers/matcher_explainable.c

@@ -0,0 +1,79 @@
+#ifndef MONGORY_MATCHER_EXPLAINABLE_C
+#define MONGORY_MATCHER_EXPLAINABLE_C
+
+#include "matcher_explainable.h"
+#include "../foundations/string_buffer.h"
+#include "base_matcher.h"
+#include "composite_matcher.h"
+#include "literal_matcher.h"
+#include "../foundations/utils.h"
+#include <stdio.h>
+
+char *mongory_matcher_title(mongory_matcher *matcher, mongory_memory_pool *pool) {
+  mongory_value *condition = matcher->condition;
+  return mongory_string_cpyf(pool, "%s: %s",
+    matcher->name,
+    condition->to_str(condition, pool)
+  );
+}
+
+char *mongory_matcher_title_with_field(mongory_matcher *matcher, mongory_memory_pool *pool) {
+  mongory_field_matcher *field_matcher = (mongory_field_matcher *)matcher;
+  mongory_value *condition = matcher->condition;
+  return mongory_string_cpyf(pool, "Field: \"%s\", to match: %s",
+    field_matcher->field,
+    condition->to_str(condition, pool)
+  );
+}
+
+static inline char *mongory_matcher_tail_connection(int count, int total) {
+  if (total == 0) {
+    return "";
+  }
+  if (total - count == 1) {
+    return "└─ ";
+  }
+  return "├─ ";
+}
+
+static inline char *mongory_matcher_indent_connection(int count, int total) {
+  if (total == 0) {
+    return "";
+  }
+  if (total - count == 1) {
+    return "   ";
+  }
+  return "│  ";
+}
+
+bool mongory_matcher_base_explain(mongory_matcher *matcher, mongory_matcher_traverse_context *ctx) {
+  char *connection = mongory_matcher_tail_connection(ctx->count, ctx->total);
+  char *title = mongory_matcher_title(matcher, ctx->pool);
+  char *prefix = (char *)ctx->acc;
+  printf("%s%s%s\n", prefix, connection, title);
+  return true;
+}
+
+bool mongory_matcher_composite_explain(mongory_matcher *matcher, mongory_matcher_traverse_context *ctx) {
+  mongory_matcher_base_explain(matcher, ctx);
+  char *prefix = (char *)ctx->acc;
+  char *indent = mongory_matcher_indent_connection(ctx->count, ctx->total);
+  ctx->acc = mongory_string_cpyf(ctx->pool, "%s%s", prefix, indent);
+  return true;
+}
+
+bool mongory_matcher_literal_explain(mongory_matcher *matcher, mongory_matcher_traverse_context *ctx) {
+  return mongory_matcher_composite_explain(matcher, ctx);
+}
+
+bool mongory_matcher_field_explain(mongory_matcher *matcher, mongory_matcher_traverse_context *ctx) {
+  char *tail_connection = mongory_matcher_tail_connection(ctx->count, ctx->total);
+  char *title = mongory_matcher_title_with_field(matcher, ctx->pool);
+  char *prefix = (char *)ctx->acc;
+  printf("%s%s%s\n", prefix, tail_connection, title);
+  char *indent = mongory_matcher_indent_connection(ctx->count, ctx->total);
+  ctx->acc = mongory_string_cpyf(ctx->pool, "%s%s", prefix, indent);
+  return true;
+}
+
+#endif /* MONGORY_MATCHER_EXPLAINABLE_C */

data/ext/mongory_ext/mongory-core/src/matchers/matcher_explainable.h

@@ -0,0 +1,23 @@
+#ifndef MONGORY_MATCHER_EXPLAINABLE_H
+#define MONGORY_MATCHER_EXPLAINABLE_H
+
+#include "mongory-core/matchers/matcher.h"
+#include "matcher_traversable.h"
+#include <mongory-core.h>
+
+
+/**
+ * @brief Explains a matcher.
+ * @param matcher The matcher to explain.
+ * @param ctx The context to use for the explanation.
+ */
+
+bool mongory_matcher_base_explain(struct mongory_matcher *matcher, mongory_matcher_traverse_context *ctx);
+
+bool mongory_matcher_composite_explain(struct mongory_matcher *matcher, mongory_matcher_traverse_context *ctx);
+
+bool mongory_matcher_field_explain(struct mongory_matcher *matcher, mongory_matcher_traverse_context *ctx);
+
+bool mongory_matcher_literal_explain(struct mongory_matcher *matcher, mongory_matcher_traverse_context *ctx);
+
+#endif /* MONGORY_MATCHER_EXPLAINABLE_H */

data/ext/mongory_ext/mongory-core/src/matchers/matcher_traversable.c

@@ -0,0 +1,60 @@
+#ifndef MONGORY_MATCHER_TRAVERSABLE_C
+#define MONGORY_MATCHER_TRAVERSABLE_C
+
+#include "matcher_traversable.h"
+#include "base_matcher.h"
+#include "composite_matcher.h"
+#include "literal_matcher.h"
+
+bool mongory_matcher_leaf_traverse(mongory_matcher *matcher, mongory_matcher_traverse_context *ctx) {
+  bool continue_traverse = ctx->callback(matcher, ctx);
+  if (!continue_traverse)
+    return false;
+  ctx->count++;
+  return true;
+}
+
+bool mongory_matcher_composite_traverse(mongory_matcher *matcher, mongory_matcher_traverse_context *ctx) {
+  void *prev_acc = ctx->acc;
+  if (!mongory_matcher_leaf_traverse(matcher, ctx))
+    return false;
+  mongory_composite_matcher *composite = (mongory_composite_matcher *)matcher;
+  mongory_array *children = composite->children;
+  int total = (int)children->count;
+  mongory_matcher_traverse_context child_ctx = {
+      .pool = ctx->pool,
+      .level = ctx->level + 1,
+      .count = 0,
+      .total = total,
+      .acc = ctx->acc,
+      .callback = ctx->callback,
+  };
+
+  for (int i = 0; i < total; i++) {
+    mongory_matcher *child = (mongory_matcher *)children->get(children, i);
+    if (!child->traverse(child, &child_ctx))
+      return false;
+  }
+  ctx->acc = prev_acc;
+  return true;
+}
+
+bool mongory_matcher_literal_traverse(mongory_matcher *matcher, mongory_matcher_traverse_context *ctx) {
+  void *prev_acc = ctx->acc;
+  if (!mongory_matcher_leaf_traverse(matcher, ctx))
+    return false;
+  mongory_literal_matcher *literal = (mongory_literal_matcher *)matcher;
+  mongory_matcher *next_matcher = literal->array_record_matcher ? literal->array_record_matcher : literal->delegate_matcher;
+  mongory_matcher_traverse_context child_ctx = {
+      .pool = ctx->pool,
+      .level = ctx->level + 1,
+      .count = 0,
+      .total = 1,
+      .acc = ctx->acc,
+      .callback = ctx->callback,
+  };
+  bool result = next_matcher->traverse(next_matcher, &child_ctx);
+  ctx->acc = prev_acc;
+  return result;
+}
+#endif /* MONGORY_MATCHER_TRAVERSABLE_C */

data/ext/mongory_ext/mongory-core/src/matchers/matcher_traversable.h

@@ -0,0 +1,23 @@
+#ifndef MONGORY_MATCHER_TRAVERSABLE_H
+#define MONGORY_MATCHER_TRAVERSABLE_H
+
+#include "mongory-core/matchers/matcher.h"
+
+typedef struct mongory_matcher_traverse_context mongory_matcher_traverse_context;
+typedef bool (*mongory_matcher_traverse_func)(mongory_matcher *matcher, mongory_matcher_traverse_context *ctx);
+struct mongory_matcher_traverse_context {
+  mongory_memory_pool *pool;
+  int level;
+  int count;
+  int total;
+  void *acc;
+  mongory_matcher_traverse_func callback;
+} ;
+
+bool mongory_matcher_leaf_traverse(mongory_matcher *matcher, mongory_matcher_traverse_context *ctx);
+
+bool mongory_matcher_composite_traverse(mongory_matcher *matcher, mongory_matcher_traverse_context *ctx);
+
+bool mongory_matcher_literal_traverse(mongory_matcher *matcher, mongory_matcher_traverse_context *ctx);
+
+#endif /* MONGORY_MATCHER_TRAVERSABLE_H */