mongory 0.6.3 → 0.7.0

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

@@ -0,0 +1,107 @@
+#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 <stdio.h>
+
+char *mongory_matcher_title(mongory_matcher *matcher, mongory_memory_pool *pool) {
+  mongory_string_buffer *buffer = mongory_string_buffer_new(pool);
+  mongory_string_buffer_append(buffer, matcher->name);
+  mongory_string_buffer_append(buffer, ": ");
+  mongory_value *condition = matcher->condition;
+  mongory_string_buffer_append(buffer, condition->to_str(condition, pool));
+  return mongory_string_buffer_cstr(buffer);
+}
+
+char *mongory_matcher_title_with_field(mongory_matcher *matcher, mongory_memory_pool *pool) {
+  mongory_string_buffer *buffer = mongory_string_buffer_new(pool);
+  mongory_field_matcher *field_matcher = (mongory_field_matcher *)matcher;
+  mongory_string_buffer_appendf(buffer, "Field: \"%s\", to match: ", field_matcher->field);
+  mongory_value *condition = field_matcher->literal.base.condition;
+  mongory_string_buffer_append(buffer, condition->to_str(condition, pool));
+  return mongory_string_buffer_cstr(buffer);
+}
+
+static inline char *mongory_matcher_tail_connection(int count, int total) {
+  if (count == (total - 1)) {
+    return "└─ ";
+  } else if (total == 0) {
+    return "";
+  }
+  return "├─ ";
+}
+
+static inline char *mongory_matcher_indent_connection(int count, int total) {
+  if (count < total) {
+    return "│  ";
+  } else if (total == 0) {
+    return "";
+  }
+  return "   ";
+}
+
+void mongory_matcher_base_explain(mongory_matcher *matcher, mongory_matcher_explain_context *ctx) {
+  char *connection = mongory_matcher_tail_connection(ctx->count, ctx->total);
+  ctx->count++;
+  char *title = mongory_matcher_title(matcher, ctx->pool);
+  printf("%s%s%s\n", ctx->prefix, connection, title);
+}
+
+void mongory_matcher_traverse_explain(mongory_matcher *matcher, mongory_matcher_explain_context *ctx) {
+  mongory_composite_matcher *composite = (mongory_composite_matcher *)matcher;
+  mongory_array *children = composite->children;
+  int total = (int)children->count;
+  for (int i = 0; i < total; i++) {
+    mongory_matcher *child = (mongory_matcher *)children->get(children, i);
+    child->explain(child, ctx);
+  }
+}
+
+void mongory_matcher_composite_explain(mongory_matcher *matcher, mongory_matcher_explain_context *ctx) {
+  mongory_matcher_base_explain(matcher, ctx);
+  mongory_string_buffer *buffer = mongory_string_buffer_new(ctx->pool);
+  mongory_string_buffer_appendf(buffer, "%s%s", ctx->prefix, mongory_matcher_indent_connection(ctx->count, ctx->total));
+  mongory_matcher_explain_context child_ctx = {
+      .pool = ctx->pool,
+      .count = 0,
+      .total = matcher->sub_count,
+      .prefix = mongory_string_buffer_cstr(buffer),
+  };
+  mongory_matcher_traverse_explain(matcher, &child_ctx);
+}
+
+static inline void mongory_matcher_literal_shared_explain(mongory_matcher *matcher, mongory_matcher_explain_context *ctx) {
+  mongory_literal_matcher *literal = (mongory_literal_matcher *)matcher;
+  mongory_string_buffer *buffer = mongory_string_buffer_new(ctx->pool);
+  mongory_string_buffer_appendf(buffer, "%s%s", ctx->prefix, mongory_matcher_indent_connection(ctx->count, ctx->total));
+  mongory_matcher_explain_context child_ctx = {
+      .pool = ctx->pool,
+      .count = 0,
+      .total = matcher->sub_count,
+      .prefix = mongory_string_buffer_cstr(buffer),
+  };
+  if (literal->array_record_matcher) {
+    literal->array_record_matcher->explain(literal->array_record_matcher, &child_ctx);
+  } else {
+    literal->delegate_matcher->explain(literal->delegate_matcher, &child_ctx);
+  }
+}
+
+void mongory_matcher_literal_explain(mongory_matcher *matcher, mongory_matcher_explain_context *ctx) {
+  mongory_matcher_base_explain(matcher, ctx);
+  mongory_matcher_literal_shared_explain(matcher, ctx);
+}
+
+void mongory_matcher_field_explain(mongory_matcher *matcher, mongory_matcher_explain_context *ctx) {
+  char *connection = mongory_matcher_tail_connection(ctx->count, ctx->total);
+  char *title = mongory_matcher_title_with_field(matcher, ctx->pool);
+  ctx->count++;
+  printf("%s%s%s\n", ctx->prefix, connection, title);
+  mongory_matcher_literal_shared_explain(matcher, ctx);
+}
+
+#endif /* MONGORY_MATCHER_EXPLAINABLE_C */

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

@@ -0,0 +1,50 @@
+#ifndef MONGORY_MATCHER_EXPLAINABLE_H
+#define MONGORY_MATCHER_EXPLAINABLE_H
+
+#include "mongory-core/matchers/matcher.h"
+#include <mongory-core.h>
+
+/**
+ * @brief Context for explaining a matcher.
+ *
+ * @param pool The pool to use for the explanation.
+ * @param count The count of the matcher.
+ * @param total The total number of matchers.
+ * @param prefix The prefix to use for the explanation.
+ */
+typedef struct mongory_matcher_explain_context {
+  mongory_memory_pool *pool;
+  int count;
+  int total;
+  char *prefix;
+} mongory_matcher_explain_context;
+
+/**
+ * @brief Function pointer type for a matcher's explanation logic.
+ *
+ * @param matcher The matcher to explain.
+ * @param ctx The context to use for the explanation.
+ */
+typedef void (*mongory_matcher_explain_func)(struct mongory_matcher *matcher, mongory_matcher_explain_context *ctx);
+
+/**
+ * @brief Explains a matcher.
+ * @param matcher The matcher to explain.
+ * @param ctx The context to use for the explanation.
+ */
+
+char *mongory_matcher_title(struct mongory_matcher *matcher, mongory_memory_pool *pool);
+
+char *mongory_matcher_title_with_field(struct mongory_matcher *matcher, mongory_memory_pool *pool);
+
+void mongory_matcher_base_explain(struct mongory_matcher *matcher, mongory_matcher_explain_context *ctx);
+
+void mongory_matcher_composite_explain(struct mongory_matcher *matcher, mongory_matcher_explain_context *ctx);
+
+void mongory_matcher_traverse_explain(struct mongory_matcher *matcher, mongory_matcher_explain_context *ctx);
+
+void mongory_matcher_field_explain(struct mongory_matcher *matcher, mongory_matcher_explain_context *ctx);
+
+void mongory_matcher_literal_explain(struct mongory_matcher *matcher, mongory_matcher_explain_context *ctx);
+
+#endif /* MONGORY_MATCHER_EXPLAINABLE_H */

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

@@ -0,0 +1,55 @@
+#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) {
+  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;
+  }
+  return true;
+}
+
+bool mongory_matcher_literal_traverse(mongory_matcher *matcher, mongory_matcher_traverse_context *ctx) {
+  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,
+  };
+  return next_matcher->traverse(next_matcher, &child_ctx);
+}
+#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_memory_pool *pool;
+  int level;
+  int count;
+  int total;
+  void *acc;
+  bool (*callback)(mongory_matcher *matcher, struct mongory_matcher_traverse_context *ctx);
+} mongory_matcher_traverse_context;
+
+typedef bool (*mongory_matcher_traverse_func)(mongory_matcher *matcher, mongory_matcher_traverse_context *ctx);
+
+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 */