mongory 0.7.8-x64-mingw-ucrt → 0.8.0-x64-mingw-ucrt

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: be58a265ee32174ecb4d519e38b47527684cd6c1e23a8d01d0b0d2f88c6d4570
-  data.tar.gz: 65f05b2caec29a64b738483e3e007b63124efe9c61e45c6de21364c3f9122c66
+  metadata.gz: 0560f881e0b3bfe0389307652ae0a1afa3c7da61082caf2d9864479ce8f70e5f
+  data.tar.gz: 71610667bc9533393331354d1cb931c5c764ddf9ea08dd67eddc64eae7819ad9
 SHA512:
-  metadata.gz: 93229abe702b61ab7a9e4b246d054806415e9f51bddfd6be8f57acc34623c7e7e340b36b0e51f513508e16927813e6b525fbbb90e8390bff84b8048454cb25d9
-  data.tar.gz: c35113a4740b182c2c611434d0cdd760a54a07c72e213368bf8eea8ce65b89d3cd574c6ff3716ab4d2548e483bf34dd9dabd65927675035ab621d08fe1b87f37
+  metadata.gz: 4b1dc0fb39f810d07ff6152ae8091595508653fa111863eb1adc39853718e41b1a103ee44c41de7d309b0262aa5b5fb713d4d96d9de316de920e0a762b9e0582
+  data.tar.gz: a2fba2d4f184f6e1c3412583774f00abd872a6ee549a7b9536894ea67f38180245f95a33b559becbef570155b279a366724cba07629b5561bae663e3459277f9

data/README.md

@@ -1,6 +1,7 @@
-# Mongory-rb
+# Mongory
+### Let you query everywhere !
 
-A Mongo-like in-memory query DSL for Ruby.
+This is a Mongo-like in-memory query DSL for Ruby.
 
 Mongory lets you filter and query in-memory collections using syntax and semantics similar to MongoDB. It is designed for expressive chaining, symbolic operators, and composable matchers.
 
@@ -53,7 +54,18 @@ gem 'mongory'
 
 #### Before installing: install build tools
 
-Mongory ships with an optional native extension. Before installing the gem, make sure your system has a C build toolchain (gcc/clang and make). Install the toolchain with the following commands for your platform:
+Mongory ships with an optional native C extension.
+Before installing Mongory, make sure these following precompiled package support your platform:
+- x86_64-linux-musl (Linux)
+- aarch64-linux-musl (Linux)
+- x86_64-linux (Linux)
+- aarch64-linux (Linux)
+- x86_64-darwin (MacOS Intel)
+- arm64-darwin (MacOS Apple Silicon)
+- x64-mingw32 (Windows)
+- x64-mingw-ucrt (Windows)
+
+If your platform excludes, make sure your system has a C build toolchain (gcc/clang and make). Install the toolchain with the following commands for your platform:
 
 - Debian/Ubuntu (including ruby:*-slim base images)
 ```bash
@@ -85,19 +97,6 @@ yum groupinstall -y "Development Tools"
 xcode-select --install
 ```
 
-#### Rails Generator
-
-You can install a starter configuration with:
-
-```bash
-rails g mongory:install
-```
-
-This will generate `config/initializers/mongory.rb` and set up:
-- Optional symbol operator snippets (e.g. `:age.gt => 18`)
-- Class registration (e.g. `Array`, `ActiveRecord::Relation`, etc.)
-- Custom value/key converters for your ORM
-
 ### Basic Usage
 ```ruby
 records = [
@@ -119,29 +118,18 @@ limited = records.mongory
   .where(:age.gte => 18)       # Conditions apply to limited set
 ```
 
-### C Extension (Optional but Recommended)
-
-Mongory-rb includes an optional high-performance C extension powered by [mongory-core](https://github.com/mongoryhq/mongory-core):
+#### Rails Generator
 
-**System Dependencies:**
-- C99-compatible compiler (gcc/clang)
-- CMake >= 3.12 (optional; only needed if you want to build `mongory-core` standalone or run its native tests)
+You can install a starter configuration with:
 
-**Installation:**
 ```bash
-# macOS
-brew install cmake
-
-# Ubuntu/Debian
-sudo apt install cmake build-essential
-
-# CentOS/RHEL
-sudo yum install cmake gcc make
+rails g mongory:install
 ```
 
-The C extension provides significant performance improvements for large datasets. If not available, Mongory-rb automatically falls back to pure Ruby implementation.
-
-Note: The Ruby C extension is built via Ruby's `mkmf` (see `ext/mongory_ext/extconf.rb`) and compiles `mongory-core` sources directly. You do not need CMake for normal gem installation.
+This will generate `config/initializers/mongory.rb` and set up:
+- Optional symbol operator snippets (e.g. `:age.gt => 18`)
+- Class registration (e.g. `Array`, `ActiveRecord::Relation`, etc.)
+- Custom value/key converters for your ORM
 
 ## Positioning
 
@@ -201,8 +189,8 @@ This will:
 
 The generated matcher will:
 - Be named `ClassInMatcher`
-- Register the operator as `$classIn`
-- Be available as `:class_in` in queries
+- Register the operator as `$classIn` makes it available in queries
+- Enable `:field.class_in` query snippet (If symbol snippet enabled)
 
 Example usage of the generated matcher:
 ```ruby
@@ -248,8 +236,7 @@ User.where(status: 'active').mongory.where(:age.gte => 18, :name.regex => "^S.+"
 ```
 
 This injects a `.mongory` method via an internal extension module.
-
-Internally, the query is compiled into a matcher tree using the `QueryMatcher` and `ConditionConverter`.
+Internally, the query is compiled into a matcher tree.
 
 | Method | Description | Example |
 |--------|-------------|---------|
@@ -311,19 +298,13 @@ And: {"age"=>{"$gte"=>18}, "$or"=>[{"status"=>"active"}, {"name"=>{"$regex"=>/^J
 
 This helps you understand how your query is being processed and can be useful for debugging complex conditions.
 
-Or use the debugger for detailed matching process:
+Or use trace for detailed matching process:
 ```ruby
-# Enable debugging
-Mongory.debugger.enable
-
 # Execute your query
 query = Mongory.build_query(users).where(age: { :$gt => 18 })
-query.each do |user|
+query.trace do |user|
   puts user
 end
-
-# Display the debug trace
-Mongory.debugger.display
 ```
 
 The debug output will show detailed matching process with full class names:
@@ -351,6 +332,7 @@ The debug output includes:
 | Pattern      | `$regex`                            |
 | Presence     | `$exists`, `$present`               |
 | Nested Match | `$elemMatch`, `$every`              |
+| Other        | `$size`                             |
 
 Note: Some operators are Mongory-specific and not available in MongoDB:
 - `$present`: Checks if a field is considered "present" (not nil, not empty, not KEY_NOT_FOUND)
@@ -399,10 +381,11 @@ end
 
 1. **Debugging Queries**
    ```ruby
-   Mongory.debugger.enable
-   records.mongory.where(:age => 18).to_a
-   Mongory.debugger.display
-   Mongory.debugger.disable
+   records.mongory.where(:age => 18).trace.to_a
+   ```
+   If using C extension:
+   ```ruby
+   records.mongory.c.where(:age => 18).trace.to_a
    ```
 
 2. **Common Issues**

data/docs/clang_bridge.md

@@ -1,3 +1,27 @@
+### C Extension (Optional but Recommended)
+
+Mongory-rb includes an optional high-performance C extension powered by [mongory-core](https://github.com/mongoryhq/mongory-core):
+
+**System Dependencies:**
+- C99-compatible compiler (gcc/clang)
+- CMake >= 3.12 (optional; only needed if you want to build `mongory-core` standalone or run its native tests)
+
+**Installation:**
+```bash
+# macOS
+brew install cmake
+
+# Ubuntu/Debian
+sudo apt install cmake build-essential
+
+# CentOS/RHEL
+sudo yum install cmake gcc make
+```
+
+The C extension provides significant performance improvements for large datasets. If not available, Mongory-rb automatically falls back to pure Ruby implementation.
+
+Note: The Ruby C extension is built via Ruby's `mkmf` (see `ext/mongory_ext/extconf.rb`) and compiles `mongory-core` sources directly. You do not need CMake for normal gem installation.
+
 # Clang Bridge (C Extension)
 
 The Clang bridge connects the Ruby DSL to the `mongory-core` engine via a compact C layer. It exposes two key entry points:

data/examples/benchmark.rb

@@ -49,7 +49,7 @@ end
   # Simple query (Mongory) test
   puts "\nSimple query (Mongory) (#{size} records):"
   gc_handler do
-    builder = records.mongory.where(:age.gte => 18)
+    builder = records.mongory.where({:age.gte => 18})
     5.times do
       result = Benchmark.measure do
         builder.to_a
@@ -62,7 +62,7 @@ end
   # Simple query (Mongory::CMatcher) test
   puts "\nSimple query (Mongory::CMatcher) (#{size} records):"
   gc_handler do
-    matcher = Mongory::CMatcher.new(:age.gte => 18)
+    matcher = Mongory::CMatcher.new({:age.gte => 18})
     5.times do
       result = Benchmark.measure do
         records.select { |r| matcher.match?(r) }
@@ -75,7 +75,7 @@ end
   # Simple query (Mongory::CQueryBuilder) test
   puts "\nSimple query (Mongory::CQueryBuilder) (#{size} records):"
   gc_handler do
-    builder = Mongory::CQueryBuilder.new(records).where(:age.gte => 18)
+    builder = Mongory::CQueryBuilder.new(records).where({:age.gte => 18})
     5.times do
       result = Benchmark.measure do
         builder.to_a
@@ -138,12 +138,12 @@ end
 
   puts "\nComplex query (Mongory) use CMatcher (#{size} records):"
   gc_handler do
-    matcher = Mongory::CMatcher.new(
+    matcher = Mongory::CMatcher.new({
       '$or' => [
         { :age.gte => 18 },
         { status: 'active' }
       ]
-    )
+    })
     5.times do
       result = Benchmark.measure do
         records.select { |r| matcher.match?(r) }
@@ -167,18 +167,4 @@ end
     end
     raise "count mismatch" if builder.count != count_of_complex_query
   end
-
-  puts "\nTest Mongory::CMatcher#trace"
-  matcher = Mongory::CMatcher.new(
-    '$or' => [
-      { :age.gte => 18 },
-      { status: 'active' }
-    ]
-  )
-  # matcher.enable_trace
-  records.sample(30).each do |r|
-    matcher.trace(r)
-  end
-  # matcher.print_trace
-  # matcher.disable_trace
 end

data/ext/mongory_ext/mongory_ext.c

@@ -26,34 +26,34 @@ static VALUE inMongoryDataConverter;
 static VALUE inMongoryConditionConverter;
 
 // Matcher wrapper structure
-typedef struct ruby_mongory_matcher_t {
+typedef struct rb_mongory_matcher_t {
   mongory_matcher *matcher;
   mongory_value *condition;
   mongory_memory_pool *pool;
   mongory_memory_pool *scratch_pool;
+  mongory_memory_pool *trace_pool;
   mongory_table *string_map;
   mongory_table *symbol_map;
   mongory_array *mark_list;
-  bool trace_enabled;
   VALUE ctx;
-} ruby_mongory_matcher_t;
+} rb_mongory_matcher_t;
 
-typedef struct ruby_mongory_memory_pool_t {
+typedef struct rb_mongory_memory_pool_t {
   mongory_memory_pool base;
-  ruby_mongory_matcher_t *owner;
-} ruby_mongory_memory_pool_t;
+  rb_mongory_matcher_t *owner;
+} rb_mongory_memory_pool_t;
 
-typedef struct ruby_mongory_table_t {
+typedef struct rb_mongory_table_t {
   mongory_table base;
   VALUE rb_hash;
-  ruby_mongory_matcher_t *owner;
-} ruby_mongory_table_t;
+  rb_mongory_matcher_t *owner;
+} rb_mongory_table_t;
 
-typedef struct ruby_mongory_array_t {
+typedef struct rb_mongory_array_t {
   mongory_array base;
   VALUE rb_array;
-  ruby_mongory_matcher_t *owner;
-} ruby_mongory_array_t;
+  rb_mongory_matcher_t *owner;
+} rb_mongory_array_t;
 
 typedef struct {
   mongory_table *table;
@@ -61,23 +61,23 @@ typedef struct {
 } hash_conv_ctx;
 
 // Forward declarations
-static void ruby_mongory_matcher_mark(void *ptr);
-static void ruby_mongory_matcher_free(void *ptr);
-mongory_value *ruby_to_mongory_value_deep(mongory_memory_pool *pool, VALUE rb_value);
-mongory_value *ruby_to_mongory_value_shallow(mongory_memory_pool *pool, VALUE rb_value);
-mongory_value *ruby_mongory_table_wrap(mongory_memory_pool *pool, VALUE rb_hash);
-mongory_value *ruby_mongory_array_wrap(mongory_memory_pool *pool, VALUE rb_array);
-static VALUE cache_fetch_string(ruby_mongory_matcher_t *owner, const char *key);
-static VALUE cache_fetch_symbol(ruby_mongory_matcher_t *owner, const char *key);
-static ruby_mongory_memory_pool_t *ruby_mongory_memory_pool_new();
-static void rb_mongory_matcher_parse_argv(ruby_mongory_matcher_t *wrapper, int argc, VALUE *argv);
-static bool mongory_error_handling(mongory_memory_pool *pool, char *error_message);
-
-static const rb_data_type_t ruby_mongory_matcher_type = {
+static void rb_mongory_matcher_mark(void *ptr);
+static void rb_mongory_matcher_free(void *ptr);
+mongory_value *rb_to_mongory_value_deep(mongory_memory_pool *pool, VALUE rb_value);
+mongory_value *rb_to_mongory_value_shallow(mongory_memory_pool *pool, VALUE rb_value);
+mongory_value *rb_mongory_table_wrap(mongory_memory_pool *pool, VALUE rb_hash);
+mongory_value *rb_mongory_array_wrap(mongory_memory_pool *pool, VALUE rb_array);
+static VALUE cache_fetch_string(rb_mongory_matcher_t *owner, const char *key);
+static VALUE cache_fetch_symbol(rb_mongory_matcher_t *owner, const char *key);
+static rb_mongory_memory_pool_t *rb_mongory_memory_pool_new();
+static void rb_mongory_matcher_parse_argv(rb_mongory_matcher_t *wrapper, int argc, VALUE *argv);
+static bool rb_mongory_error_handling(mongory_memory_pool *pool, char *error_message);
+
+static const rb_data_type_t rb_mongory_matcher_type = {
   .wrap_struct_name = "mongory_matcher",
   .function = {
-    .dmark = ruby_mongory_matcher_mark,
-    .dfree = ruby_mongory_matcher_free,
+    .dmark = rb_mongory_matcher_mark,
+    .dfree = rb_mongory_matcher_free,
     .dsize = NULL,
   },
   .flags = RUBY_TYPED_FREE_IMMEDIATELY,
@@ -88,30 +88,38 @@ static const rb_data_type_t ruby_mongory_matcher_type = {
  */
 
 // Mongory::CMatcher.new(condition)
-static VALUE ruby_mongory_matcher_new(int argc, VALUE *argv, VALUE class) {
-  ruby_mongory_memory_pool_t *matcher_pool = ruby_mongory_memory_pool_new();
-  ruby_mongory_memory_pool_t *scratch_pool = ruby_mongory_memory_pool_new();
-  ruby_mongory_matcher_t *wrapper = ALLOC(ruby_mongory_matcher_t);
-  wrapper->pool = &matcher_pool->base;
-  wrapper->scratch_pool = &scratch_pool->base;
-  wrapper->string_map = mongory_table_new(wrapper->pool);
-  wrapper->symbol_map = mongory_table_new(wrapper->pool);
-  wrapper->mark_list = mongory_array_new(wrapper->pool);
-  wrapper->trace_enabled = false;
+static VALUE rb_mongory_matcher_new(int argc, VALUE *argv, VALUE class) {
+  rb_mongory_memory_pool_t *matcher_pool = rb_mongory_memory_pool_new();
+  mongory_memory_pool *matcher_pool_base = &matcher_pool->base;
+  rb_mongory_memory_pool_t *scratch_pool = rb_mongory_memory_pool_new();
+  mongory_memory_pool *scratch_pool_base = &scratch_pool->base;
+  rb_mongory_matcher_t *wrapper = ALLOC(rb_mongory_matcher_t);
+  wrapper->pool = matcher_pool_base;
+  wrapper->scratch_pool = scratch_pool_base;
+  wrapper->trace_pool = NULL;
+  wrapper->ctx = NULL;
+  wrapper->string_map = mongory_table_new(matcher_pool_base);
+  wrapper->symbol_map = mongory_table_new(matcher_pool_base);
+  wrapper->mark_list = mongory_array_new(matcher_pool_base);
+  wrapper->condition = NULL;
+  wrapper->matcher = NULL;
   matcher_pool->owner = wrapper;
   scratch_pool->owner = wrapper;
   rb_mongory_matcher_parse_argv(wrapper, argc, argv);
 
-  mongory_matcher *matcher = mongory_matcher_new(wrapper->pool, wrapper->condition, wrapper->ctx);
-  if (mongory_error_handling(wrapper->pool, "Failed to create matcher")) {
+  mongory_matcher *matcher = mongory_matcher_new(matcher_pool_base, wrapper->condition, wrapper->ctx);
+  if (rb_mongory_error_handling(matcher_pool_base, "Failed to create matcher")) {
+    matcher_pool_base->free(matcher_pool_base);
+    scratch_pool_base->free(scratch_pool_base);
+    xfree(wrapper);
     return Qnil;
   }
 
   wrapper->matcher = matcher;
-  return TypedData_Wrap_Struct(class, &ruby_mongory_matcher_type, wrapper);
+  return TypedData_Wrap_Struct(class, &rb_mongory_matcher_type, wrapper);
 }
 
-static void rb_mongory_matcher_parse_argv(ruby_mongory_matcher_t *wrapper, int argc, VALUE *argv) {
+static void rb_mongory_matcher_parse_argv(rb_mongory_matcher_t *self, int argc, VALUE *argv) {
   VALUE condition, kw_hash;
   rb_scan_args(argc, argv, "1:", &condition, &kw_hash);
   const ID ctx_id[1] = { rb_intern("context") };
@@ -120,40 +128,50 @@ static void rb_mongory_matcher_parse_argv(ruby_mongory_matcher_t *wrapper, int a
     rb_get_kwargs(kw_hash, ctx_id, 1, 0, kw_vals);
   }
   if (kw_vals[0] != Qundef) {
-    wrapper->ctx = kw_vals[0];
+    self->ctx = kw_vals[0];
   } else {
-    wrapper->ctx = rb_funcall(cMongoryMatcherContext, rb_intern("new"), 0);
+    self->ctx = rb_funcall(cMongoryMatcherContext, rb_intern("new"), 0);
   }
   VALUE converted_condition = rb_funcall(inMongoryConditionConverter, rb_intern("convert"), 1, condition);
-  wrapper->condition = ruby_to_mongory_value_deep(wrapper->pool, converted_condition);
-  wrapper->mark_list->push(wrapper->mark_list, wrapper->condition);
-  mongory_value *store_ctx = mongory_value_wrap_u(wrapper->pool, (void *)wrapper->ctx);
-  store_ctx->origin = (void *)wrapper->ctx;
-  wrapper->mark_list->push(wrapper->mark_list, store_ctx);
+  self->condition = rb_to_mongory_value_deep(self->pool, converted_condition);
+  self->mark_list->push(self->mark_list, self->condition);
+  mongory_value *store_ctx = mongory_value_wrap_u(self->pool, (void *)self->ctx);
+  store_ctx->origin = (void *)self->ctx;
+  self->mark_list->push(self->mark_list, store_ctx);
 }
 
 // Mongory::CMatcher#match(data)
-static VALUE ruby_mongory_matcher_match(VALUE self, VALUE data) {
-  ruby_mongory_matcher_t *wrapper;
-  TypedData_Get_Struct(self, ruby_mongory_matcher_t, &ruby_mongory_matcher_type, wrapper);
-  mongory_value *data_value;
-  data_value = ruby_to_mongory_value_shallow(wrapper->scratch_pool, data);
-  if (mongory_error_handling(wrapper->scratch_pool, "Match failed")) {
+static VALUE rb_mongory_matcher_match(VALUE self, VALUE data) {
+  rb_mongory_matcher_t *self_wrapper;
+  TypedData_Get_Struct(self, rb_mongory_matcher_t, &rb_mongory_matcher_type, self_wrapper);
+  mongory_matcher *matcher = self_wrapper->matcher;
+  mongory_memory_pool *scratch_pool = self_wrapper->scratch_pool;
+  mongory_memory_pool *trace_pool = self_wrapper->trace_pool;
+  mongory_value *data_value = rb_to_mongory_value_shallow(scratch_pool, data);
+
+  if (rb_mongory_error_handling(scratch_pool, "Match failed")) {
     return Qnil;
   }
-  bool result = mongory_matcher_match(wrapper->matcher, data_value);
-  if (!wrapper->trace_enabled) {
-    wrapper->scratch_pool->reset(wrapper->scratch_pool);
+
+  bool result = mongory_matcher_match(matcher, data_value);
+
+  if (trace_pool) {
+    mongory_matcher_print_trace(matcher);
+    trace_pool->reset(trace_pool);
+    mongory_matcher_enable_trace(matcher, trace_pool);
   }
+
+  scratch_pool->reset(scratch_pool);
+
   return result ? Qtrue : Qfalse;
 }
 
 // Mongory::CMatcher#explain
-static VALUE ruby_mongory_matcher_explain(VALUE self) {
-  ruby_mongory_matcher_t *wrapper;
-  TypedData_Get_Struct(self, ruby_mongory_matcher_t, &ruby_mongory_matcher_type, wrapper);
+static VALUE rb_mongory_matcher_explain(VALUE self) {
+  rb_mongory_matcher_t *wrapper;
+  TypedData_Get_Struct(self, rb_mongory_matcher_t, &rb_mongory_matcher_type, wrapper);
   mongory_matcher_explain(wrapper->matcher, wrapper->scratch_pool);
-  if (mongory_error_handling(wrapper->scratch_pool, "Explain failed")) {
+  if (rb_mongory_error_handling(wrapper->scratch_pool, "Explain failed")) {
     return Qnil;
   }
   wrapper->scratch_pool->reset(wrapper->scratch_pool);
@@ -161,78 +179,91 @@ static VALUE ruby_mongory_matcher_explain(VALUE self) {
 }
 
 // Mongory::CMatcher#trace(data)
-static VALUE ruby_mongory_matcher_trace(VALUE self, VALUE data) {
-  ruby_mongory_matcher_t *wrapper;
-  TypedData_Get_Struct(self, ruby_mongory_matcher_t, &ruby_mongory_matcher_type, wrapper);
-  mongory_value *data_value = ruby_to_mongory_value_shallow(wrapper->scratch_pool, data);
-  if (mongory_error_handling(wrapper->scratch_pool, "Trace failed")) {
+static VALUE rb_mongory_matcher_trace(VALUE self, VALUE data) {
+  rb_mongory_matcher_t *wrapper;
+  TypedData_Get_Struct(self, rb_mongory_matcher_t, &rb_mongory_matcher_type, wrapper);
+  mongory_memory_pool *trace_pool = mongory_memory_pool_new();
+  mongory_value *data_value = rb_to_mongory_value_shallow(trace_pool, data);
+
+  if (rb_mongory_error_handling(trace_pool, "Trace failed")) {
+    trace_pool->free(trace_pool);
     return Qnil;
   }
+
   bool matched = mongory_matcher_trace(wrapper->matcher, data_value);
-  wrapper->scratch_pool->reset(wrapper->scratch_pool);
+  trace_pool->free(trace_pool);
+
   return matched ? Qtrue : Qfalse;
 }
 
 // Mongory::CMatcher#enable_trace
-static VALUE ruby_mongory_matcher_enable_trace(VALUE self) {
-  ruby_mongory_matcher_t *wrapper;
-  TypedData_Get_Struct(self, ruby_mongory_matcher_t, &ruby_mongory_matcher_type, wrapper);
-  mongory_matcher_enable_trace(wrapper->matcher, wrapper->scratch_pool);
-  if (mongory_error_handling(wrapper->scratch_pool, "Enable trace failed")) {
+static VALUE rb_mongory_matcher_enable_trace(VALUE self) {
+  rb_mongory_matcher_t *wrapper;
+  TypedData_Get_Struct(self, rb_mongory_matcher_t, &rb_mongory_matcher_type, wrapper);
+  mongory_memory_pool *trace_pool = rb_mongory_memory_pool_new();
+  mongory_matcher_enable_trace(wrapper->matcher, trace_pool);
+
+  if (rb_mongory_error_handling(trace_pool, "Enable trace failed")) {
+    trace_pool->free(trace_pool);
     return Qnil;
   }
-  wrapper->trace_enabled = true;
+  wrapper->trace_pool = trace_pool;
+
   return Qnil;
 }
 
 // Mongory::CMatcher#disable_trace
-static VALUE ruby_mongory_matcher_disable_trace(VALUE self) {
-  ruby_mongory_matcher_t *wrapper;
-  TypedData_Get_Struct(self, ruby_mongory_matcher_t, &ruby_mongory_matcher_type, wrapper);
+static VALUE rb_mongory_matcher_disable_trace(VALUE self) {
+  rb_mongory_matcher_t *wrapper;
+  TypedData_Get_Struct(self, rb_mongory_matcher_t, &rb_mongory_matcher_type, wrapper);
+  mongory_memory_pool *trace_pool = wrapper->trace_pool;
   mongory_matcher_disable_trace(wrapper->matcher);
-  if (mongory_error_handling(wrapper->scratch_pool, "Disable trace failed")) {
-    return Qnil;
-  }
-  wrapper->scratch_pool->reset(wrapper->scratch_pool);
-  wrapper->trace_enabled = false;
+  rb_mongory_error_handling(trace_pool, "Disable trace failed");
+  trace_pool->free(trace_pool);
+  wrapper->trace_pool = NULL;
+
   return Qnil;
 }
 
 // Mongory::CMatcher#print_trace
-static VALUE ruby_mongory_matcher_print_trace(VALUE self) {
-  ruby_mongory_matcher_t *wrapper;
-  TypedData_Get_Struct(self, ruby_mongory_matcher_t, &ruby_mongory_matcher_type, wrapper);
+static VALUE rb_mongory_matcher_print_trace(VALUE self) {
+  rb_mongory_matcher_t *wrapper;
+  TypedData_Get_Struct(self, rb_mongory_matcher_t, &rb_mongory_matcher_type, wrapper);
   mongory_matcher_print_trace(wrapper->matcher);
-  mongory_error_handling(wrapper->scratch_pool, "Print trace failed");
+  rb_mongory_error_handling(wrapper->trace_pool, "Print trace failed");
+
   return Qnil;
 }
 
 // Mongory::CMatcher#condition
-static VALUE ruby_mongory_matcher_condition(VALUE self) {
-  ruby_mongory_matcher_t *wrapper;
-  TypedData_Get_Struct(self, ruby_mongory_matcher_t, &ruby_mongory_matcher_type, wrapper);
+static VALUE rb_mongory_matcher_condition(VALUE self) {
+  rb_mongory_matcher_t *wrapper;
+  TypedData_Get_Struct(self, rb_mongory_matcher_t, &rb_mongory_matcher_type, wrapper);
+
   return (VALUE)wrapper->condition->origin;
 }
 
 // Mongory::CMatcher#context
-static VALUE ruby_mongory_matcher_context(VALUE self) {
-  ruby_mongory_matcher_t *wrapper;
-  TypedData_Get_Struct(self, ruby_mongory_matcher_t, &ruby_mongory_matcher_type, wrapper);
+static VALUE rb_mongory_matcher_context(VALUE self) {
+  rb_mongory_matcher_t *wrapper;
+  TypedData_Get_Struct(self, rb_mongory_matcher_t, &rb_mongory_matcher_type, wrapper);
+
   return wrapper->ctx ? wrapper->ctx : Qnil;
 }
 
 // Mongory::CMatcher.trace_result_colorful=(colorful)
-static VALUE ruby_mongory_matcher_trace_result_colorful(VALUE self, VALUE colorful) {
+static VALUE rb_mongory_matcher_trace_result_colorful(VALUE self, VALUE colorful) {
   (void)self;
   mongory_matcher_trace_result_colorful_set(RTEST(colorful));
+
   return Qnil;
 }
 
 /**
  * Create a new memory pool
  */
-static ruby_mongory_memory_pool_t *ruby_mongory_memory_pool_new() {
-  ruby_mongory_memory_pool_t *pool = malloc(sizeof(ruby_mongory_memory_pool_t));
+static rb_mongory_memory_pool_t *rb_mongory_memory_pool_new() {
+  rb_mongory_memory_pool_t *pool = malloc(sizeof(rb_mongory_memory_pool_t));
   mongory_memory_pool *base = mongory_memory_pool_new();
   memcpy(&pool->base, base, sizeof(mongory_memory_pool));
   free(base);
@@ -243,12 +274,16 @@ static ruby_mongory_memory_pool_t *ruby_mongory_memory_pool_new() {
 /**
  * Ruby GC management functions
  */
-static void ruby_mongory_matcher_free(void *ptr) {
-  ruby_mongory_matcher_t *wrapper = (ruby_mongory_matcher_t *)ptr;
+static void rb_mongory_matcher_free(void *ptr) {
+  rb_mongory_matcher_t *wrapper = (rb_mongory_matcher_t *)ptr;
   mongory_memory_pool *pool = wrapper->pool;
   mongory_memory_pool *scratch_pool = wrapper->scratch_pool;
+  mongory_memory_pool *trace_pool = wrapper->trace_pool;
   pool->free(pool);
   scratch_pool->free(scratch_pool);
+  if (trace_pool) {
+    trace_pool->free(trace_pool);
+  }
   xfree(wrapper);
 }
 
@@ -264,10 +299,10 @@ static bool gc_mark_array_cb(mongory_value *value, void *acc) {
 /**
  * GC marking callback for mongory_matcher
  */
-static void ruby_mongory_matcher_mark(void *ptr) {
-  ruby_mongory_matcher_t *wrapper = (ruby_mongory_matcher_t *)ptr;
-  if (!wrapper) return;
-  wrapper->mark_list->each(wrapper->mark_list, NULL, gc_mark_array_cb);
+static void rb_mongory_matcher_mark(void *ptr) {
+  rb_mongory_matcher_t *self = (rb_mongory_matcher_t *)ptr;
+  if (!self) return;
+  self->mark_list->each(self->mark_list, NULL, gc_mark_array_cb);
 }
 
 /**
@@ -275,7 +310,7 @@ static void ruby_mongory_matcher_mark(void *ptr) {
  */
 
 // Helper function to convert Ruby value to C string
-static char *ruby_mongory_value_to_cstr(mongory_value *value, mongory_memory_pool *pool) {
+static char *rb_mongory_value_to_cstr(mongory_value *value, mongory_memory_pool *pool) {
   (void)pool;
   VALUE rb_value = (VALUE)value->origin;
   VALUE rb_str = rb_funcall(rb_value, rb_intern("inspect"), 0);
@@ -283,7 +318,7 @@ static char *ruby_mongory_value_to_cstr(mongory_value *value, mongory_memory_poo
 }
 
 // Helper function for primitive conversion of Ruby value to mongory_value
-static mongory_value *ruby_to_mongory_value_primitive(mongory_memory_pool *pool, VALUE rb_value) {
+static mongory_value *rb_to_mongory_value_primitive(mongory_memory_pool *pool, VALUE rb_value) {
   mongory_value *mg_value = NULL;
   switch (TYPE(rb_value)) {
   case T_NIL:
@@ -325,8 +360,8 @@ static mongory_value *ruby_to_mongory_value_primitive(mongory_memory_pool *pool,
   return mg_value;
 }
 // Shallow conversion: Convert Ruby value to mongory_value (fully materialize arrays/tables)
-static mongory_value *ruby_to_mongory_value_shallow_rec(mongory_memory_pool *pool, VALUE rb_value, bool converted) {
-  mongory_value *mg_value = ruby_to_mongory_value_primitive(pool, rb_value);
+static mongory_value *rb_to_mongory_value_shallow_rec(mongory_memory_pool *pool, VALUE rb_value, bool converted) {
+  mongory_value *mg_value = rb_to_mongory_value_primitive(pool, rb_value);
   if (mg_value) {
     mg_value->origin = rb_value;
     return mg_value;
@@ -334,12 +369,12 @@ static mongory_value *ruby_to_mongory_value_shallow_rec(mongory_memory_pool *poo
 
   switch (TYPE(rb_value)) {
   case T_ARRAY: {
-    mg_value = ruby_mongory_array_wrap(pool, rb_value);
+    mg_value = rb_mongory_array_wrap(pool, rb_value);
     break;
   }
 
   case T_HASH: {
-    mg_value = ruby_mongory_table_wrap(pool, rb_value);
+    mg_value = rb_mongory_table_wrap(pool, rb_value);
     break;
   }
 
@@ -349,7 +384,7 @@ static mongory_value *ruby_to_mongory_value_shallow_rec(mongory_memory_pool *poo
       break;
     } else {
       VALUE converted_value = rb_funcall(inMongoryDataConverter, rb_intern("convert"), 1, rb_value);
-      return ruby_to_mongory_value_shallow_rec(pool, converted_value, true);
+      return rb_to_mongory_value_shallow_rec(pool, converted_value, true);
     }
   }
   mg_value->origin = rb_value;
@@ -357,15 +392,15 @@ static mongory_value *ruby_to_mongory_value_shallow_rec(mongory_memory_pool *poo
 }
 
 // Shallow conversion: Convert Ruby value to mongory_value (fully materialize arrays/tables)
-mongory_value *ruby_to_mongory_value_shallow(mongory_memory_pool *pool, VALUE rb_value) {
-  return ruby_to_mongory_value_shallow_rec(pool, rb_value, false);
+mongory_value *rb_to_mongory_value_shallow(mongory_memory_pool *pool, VALUE rb_value) {
+  return rb_to_mongory_value_shallow_rec(pool, rb_value, false);
 }
 
 // Helper function for deep conversion of hash values
 static int hash_foreach_deep_convert_cb(VALUE key, VALUE val, VALUE ptr) {
   hash_conv_ctx *ctx = (hash_conv_ctx *)ptr;
-  ruby_mongory_memory_pool_t *rb_pool = (ruby_mongory_memory_pool_t *)ctx->pool;
-  ruby_mongory_matcher_t *owner = rb_pool->owner;
+  rb_mongory_memory_pool_t *rb_pool = (rb_mongory_memory_pool_t *)ctx->pool;
+  rb_mongory_matcher_t *owner = rb_pool->owner;
   mongory_table *store_map;
   char *key_str;
   if (SYMBOL_P(key)) {
@@ -378,14 +413,14 @@ static int hash_foreach_deep_convert_cb(VALUE key, VALUE val, VALUE ptr) {
   mongory_value *store = mongory_value_wrap_u(ctx->pool, NULL);
   store->origin = (void *)key;
   store_map->set(store_map, key_str, store);
-  mongory_value *cval = ruby_to_mongory_value_deep(ctx->pool, val);
+  mongory_value *cval = rb_to_mongory_value_deep(ctx->pool, val);
   ctx->table->set(ctx->table, key_str, cval);
   return ST_CONTINUE;
 }
 
 // Deep conversion: Convert Ruby value to mongory_value (fully materialize arrays/tables)
-static mongory_value *ruby_to_mongory_value_deep_rec(mongory_memory_pool *pool, VALUE rb_value, bool converted) {
-  mongory_value *mg_value = ruby_to_mongory_value_primitive(pool, rb_value);
+static mongory_value *rb_to_mongory_value_deep_rec(mongory_memory_pool *pool, VALUE rb_value, bool converted) {
+  mongory_value *mg_value = rb_to_mongory_value_primitive(pool, rb_value);
   if (mg_value) {
     mg_value->origin = rb_value;
     return mg_value;
@@ -395,7 +430,7 @@ static mongory_value *ruby_to_mongory_value_deep_rec(mongory_memory_pool *pool,
     mongory_array *array = mongory_array_new(pool);
 
     for (long i = 0; i < RARRAY_LEN(rb_value); i++) {
-      array->push(array, ruby_to_mongory_value_deep(pool, RARRAY_AREF(rb_value, i)));
+      array->push(array, rb_to_mongory_value_deep(pool, RARRAY_AREF(rb_value, i)));
     }
     mg_value = mongory_value_wrap_a(pool, array);
     break;
@@ -417,7 +452,7 @@ static mongory_value *ruby_to_mongory_value_deep_rec(mongory_memory_pool *pool,
       break;
     } else {
       VALUE converted_value = rb_funcall(inMongoryDataConverter, rb_intern("convert"), 1, rb_value);
-      mg_value = ruby_to_mongory_value_deep_rec(pool, converted_value, true);
+      mg_value = rb_to_mongory_value_deep_rec(pool, converted_value, true);
       break;
     }
   }
@@ -426,13 +461,13 @@ static mongory_value *ruby_to_mongory_value_deep_rec(mongory_memory_pool *pool,
 }
 
 // Deep conversion: Convert Ruby value to mongory_value (fully materialize arrays/tables)
-mongory_value *ruby_to_mongory_value_deep(mongory_memory_pool *pool, VALUE rb_value) {
-  return ruby_to_mongory_value_deep_rec(pool, rb_value, false);
+mongory_value *rb_to_mongory_value_deep(mongory_memory_pool *pool, VALUE rb_value) {
+  return rb_to_mongory_value_deep_rec(pool, rb_value, false);
 }
 
 // Get value from Ruby hash via mongory_table
-mongory_value *ruby_mongory_table_get(mongory_table *self, char *key) {
-  ruby_mongory_table_t *table = (ruby_mongory_table_t *)self;
+mongory_value *rb_mongory_table_get(mongory_table *self, char *key) {
+  rb_mongory_table_t *table = (rb_mongory_table_t *)self;
   VALUE rb_hash = table->rb_hash;
   VALUE rb_value = Qundef;
 
@@ -449,47 +484,47 @@ mongory_value *ruby_mongory_table_get(mongory_table *self, char *key) {
   if (rb_value == Qundef) {
     return NULL;
   }
-  return ruby_to_mongory_value_shallow(table->base.pool, rb_value);
+  return rb_to_mongory_value_shallow(table->base.pool, rb_value);
 }
 
 // Shallow conversion: Wrap Ruby hash as mongory_table
-mongory_value *ruby_mongory_table_wrap(mongory_memory_pool *pool, VALUE rb_hash) {
-  ruby_mongory_table_t *table = MG_ALLOC_PTR(pool, ruby_mongory_table_t);
-  ruby_mongory_memory_pool_t *rb_pool = (ruby_mongory_memory_pool_t *)pool;
+mongory_value *rb_mongory_table_wrap(mongory_memory_pool *pool, VALUE rb_hash) {
+  rb_mongory_table_t *table = MG_ALLOC_PTR(pool, rb_mongory_table_t);
+  rb_mongory_memory_pool_t *rb_pool = (rb_mongory_memory_pool_t *)pool;
   table->base.pool = pool;
-  table->base.get = ruby_mongory_table_get;
+  table->base.get = rb_mongory_table_get;
   table->rb_hash = rb_hash;
   table->base.count = RHASH_SIZE(rb_hash);
   table->owner = rb_pool->owner;
   mongory_value *mg_value = mongory_value_wrap_t(pool, &table->base);
   mg_value->origin = (void *)rb_hash;
-  mg_value->to_str = ruby_mongory_value_to_cstr;
+  mg_value->to_str = rb_mongory_value_to_cstr;
   return mg_value;
 }
 
 // Get value from Ruby array via mongory_array
-static mongory_value *ruby_mongory_array_get(mongory_array *self, size_t index) {
-  ruby_mongory_array_t *array = (ruby_mongory_array_t *)self;
+static mongory_value *rb_mongory_array_get(mongory_array *self, size_t index) {
+  rb_mongory_array_t *array = (rb_mongory_array_t *)self;
   VALUE rb_array = array->rb_array;
   if (index >= (size_t)RARRAY_LEN(rb_array)) {
     return NULL;
   }
   VALUE rb_value = rb_ary_entry(rb_array, index);
-  return ruby_to_mongory_value_shallow(self->pool, rb_value);
+  return rb_to_mongory_value_shallow(self->pool, rb_value);
 }
 
 // Shallow conversion: Wrap Ruby array as mongory_array
-mongory_value *ruby_mongory_array_wrap(mongory_memory_pool *pool, VALUE rb_array) {
-  ruby_mongory_array_t *array = MG_ALLOC_PTR(pool, ruby_mongory_array_t);
-  ruby_mongory_memory_pool_t *rb_pool = (ruby_mongory_memory_pool_t *)pool;
+mongory_value *rb_mongory_array_wrap(mongory_memory_pool *pool, VALUE rb_array) {
+  rb_mongory_array_t *array = MG_ALLOC_PTR(pool, rb_mongory_array_t);
+  rb_mongory_memory_pool_t *rb_pool = (rb_mongory_memory_pool_t *)pool;
   array->base.pool = pool;
-  array->base.get = ruby_mongory_array_get;
+  array->base.get = rb_mongory_array_get;
   array->rb_array = rb_array;
   array->base.count = RARRAY_LEN(rb_array);
   array->owner = rb_pool->owner;
   mongory_value *mg_value = mongory_value_wrap_a(pool, &array->base);
   mg_value->origin = (void *)rb_array;
-  mg_value->to_str = ruby_mongory_value_to_cstr;
+  mg_value->to_str = rb_mongory_value_to_cstr;
   return mg_value;
 }
 
@@ -502,7 +537,7 @@ void *mongory_value_to_ruby(mongory_memory_pool *pool, mongory_value *value) {
 }
 
 // ===== Cache helper implementations =====
-static VALUE cache_fetch_string(ruby_mongory_matcher_t *owner, const char *key) {
+static VALUE cache_fetch_string(rb_mongory_matcher_t *owner, const char *key) {
   if (!owner || !owner->string_map) return rb_utf8_str_new_cstr(key);
   mongory_value *v = owner->string_map->get(owner->string_map, (char *)key);
   if (v && v->origin) return (VALUE)v->origin;
@@ -522,7 +557,7 @@ static inline VALUE char_key_to_symbol(const char *key, rb_encoding *enc) {
 }
 
 // Cache helper for Ruby symbol keys
-static VALUE cache_fetch_symbol(ruby_mongory_matcher_t *owner, const char *key) {
+static VALUE cache_fetch_symbol(rb_mongory_matcher_t *owner, const char *key) {
   rb_encoding *enc = rb_utf8_encoding();
   if (!owner || !owner->symbol_map) {
     return char_key_to_symbol(key, enc);
@@ -538,7 +573,7 @@ static VALUE cache_fetch_symbol(ruby_mongory_matcher_t *owner, const char *key)
 }
 
 // Regex adapter bridging to Ruby's Regexp
-static bool ruby_regex_match_adapter(mongory_memory_pool *pool, mongory_value *pattern, mongory_value *value) {
+static bool rb_mongory_regex_match_adapter(mongory_memory_pool *pool, mongory_value *pattern, mongory_value *value) {
   if (!pattern || !value) {
     return false;
   }
@@ -565,7 +600,7 @@ static bool ruby_regex_match_adapter(mongory_memory_pool *pool, mongory_value *p
 }
 
 // Regex adapter bridging to Ruby's Regexp
-static char *ruby_regex_stringify_adapter(mongory_memory_pool *pool, mongory_value *pattern) {
+static char *rb_mongory_regex_stringify_adapter(mongory_memory_pool *pool, mongory_value *pattern) {
   (void)pool;
   if (pattern->type != MONGORY_TYPE_REGEX) {
     return NULL;
@@ -576,10 +611,10 @@ static char *ruby_regex_stringify_adapter(mongory_memory_pool *pool, mongory_val
 }
 
 // Custom matcher adapter bridging to Ruby's custom matcher
-static mongory_matcher_custom_context *ruby_custom_matcher_build(char *key, mongory_value *condition, void *ctx) {
+static mongory_matcher_custom_context *rb_mongory_custom_matcher_build(char *key, mongory_value *condition, void *ctx) {
   mongory_memory_pool *pool = condition->pool;
-  ruby_mongory_memory_pool_t *rb_pool = (ruby_mongory_memory_pool_t *)pool;
-  ruby_mongory_matcher_t *owner = rb_pool->owner;
+  rb_mongory_memory_pool_t *rb_pool = (rb_mongory_memory_pool_t *)pool;
+  rb_mongory_matcher_t *owner = rb_pool->owner;
   VALUE matcher_class = rb_funcall(mMongoryMatchers, rb_intern("lookup"), 1, cache_fetch_string(owner, key));
   if (matcher_class == Qnil) {
     return NULL;
@@ -611,24 +646,23 @@ static mongory_matcher_custom_context *ruby_custom_matcher_build(char *key, mong
 }
 
 // Custom matcher adapter bridging to Ruby's custom matcher
-static bool ruby_custom_matcher_match(void *ruby_matcher, mongory_value *value) {
+static bool rb_mongory_custom_matcher_match(void *ruby_matcher, mongory_value *value) {
   VALUE matcher = (VALUE)ruby_matcher;
   VALUE match_result = rb_funcall(matcher, rb_intern("match?"), 1, value->origin);
   return RTEST(match_result);
 }
 
 // Custom matcher adapter bridging to Ruby's custom matcher
-static bool ruby_custom_matcher_lookup(char *key) {
+static bool rb_mongory_custom_matcher_lookup(char *key) {
   VALUE matcher_class = rb_funcall(mMongoryMatchers, rb_intern("lookup"), 1, rb_str_new_cstr(key));
   return RTEST(matcher_class);
 }
 
 // Error handling for mongory_memory_pool
-static bool mongory_error_handling(mongory_memory_pool *pool, char *error_message) {
+static bool rb_mongory_error_handling(mongory_memory_pool *pool, char *error_message) {
   if (pool->error) {
     rb_raise(eMongoryTypeError, "%s: %s", error_message, pool->error->message);
     pool->error = NULL;
-    pool->reset(pool);
     return true;
   }
   return false;
@@ -656,28 +690,28 @@ void Init_mongory_ext(void) {
   eMongoryTypeError = rb_define_class_under(mMongory, "TypeError", eMongoryError);
 
   // Define Matcher methods
-  rb_define_singleton_method(cMongoryMatcher, "new", ruby_mongory_matcher_new, -1);
-  rb_define_singleton_method(cMongoryMatcher, "trace_result_colorful=", ruby_mongory_matcher_trace_result_colorful, 1);
-  rb_define_method(cMongoryMatcher, "match?", ruby_mongory_matcher_match, 1);
-  rb_define_method(cMongoryMatcher, "explain", ruby_mongory_matcher_explain, 0);
-  rb_define_method(cMongoryMatcher, "condition", ruby_mongory_matcher_condition, 0);
-  rb_define_method(cMongoryMatcher, "context", ruby_mongory_matcher_context, 0);
-  rb_define_method(cMongoryMatcher, "trace", ruby_mongory_matcher_trace, 1);
-  rb_define_method(cMongoryMatcher, "enable_trace", ruby_mongory_matcher_enable_trace, 0);
-  rb_define_method(cMongoryMatcher, "disable_trace", ruby_mongory_matcher_disable_trace, 0);
-  rb_define_method(cMongoryMatcher, "print_trace", ruby_mongory_matcher_print_trace, 0);
+  rb_define_singleton_method(cMongoryMatcher, "new", rb_mongory_matcher_new, -1);
+  rb_define_singleton_method(cMongoryMatcher, "trace_result_colorful=", rb_mongory_matcher_trace_result_colorful, 1);
+  rb_define_method(cMongoryMatcher, "match?", rb_mongory_matcher_match, 1);
+  rb_define_method(cMongoryMatcher, "explain", rb_mongory_matcher_explain, 0);
+  rb_define_method(cMongoryMatcher, "condition", rb_mongory_matcher_condition, 0);
+  rb_define_method(cMongoryMatcher, "context", rb_mongory_matcher_context, 0);
+  rb_define_method(cMongoryMatcher, "trace", rb_mongory_matcher_trace, 1);
+  rb_define_method(cMongoryMatcher, "enable_trace", rb_mongory_matcher_enable_trace, 0);
+  rb_define_method(cMongoryMatcher, "disable_trace", rb_mongory_matcher_disable_trace, 0);
+  rb_define_method(cMongoryMatcher, "print_trace", rb_mongory_matcher_print_trace, 0);
 
   // Set regex adapter to use Ruby's Regexp
-  mongory_regex_func_set(ruby_regex_match_adapter);
-  mongory_regex_stringify_func_set(ruby_regex_stringify_adapter);
+  mongory_regex_func_set(rb_mongory_regex_match_adapter);
+  mongory_regex_stringify_func_set(rb_mongory_regex_stringify_adapter);
 
   // Set value converter functions
-  mongory_value_converter_deep_convert_set(ruby_to_mongory_value_deep);
-  mongory_value_converter_shallow_convert_set(ruby_to_mongory_value_shallow);
+  mongory_value_converter_deep_convert_set(rb_to_mongory_value_deep);
+  mongory_value_converter_shallow_convert_set(rb_to_mongory_value_shallow);
   mongory_value_converter_recover_set(mongory_value_to_ruby);
 
   // Set custom matcher adapter
-  mongory_custom_matcher_match_func_set(ruby_custom_matcher_match);
-  mongory_custom_matcher_build_func_set(ruby_custom_matcher_build);
-  mongory_custom_matcher_lookup_func_set(ruby_custom_matcher_lookup);
+  mongory_custom_matcher_match_func_set(rb_mongory_custom_matcher_match);
+  mongory_custom_matcher_build_func_set(rb_mongory_custom_matcher_build);
+  mongory_custom_matcher_lookup_func_set(rb_mongory_custom_matcher_lookup);
 }

data/lib/mongory/c_matcher.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Mongory
+  # This class is the C extension of Mongory::QueryMatcher.
+  # It is used to match records using the C extension.
+  # @example
+  #   matcher = Mongory::CMatcher.new(condition)
+  #   matcher.match?(record) #=> true
+  #   # or
+  #   collection.mongory.c.where(condition).to_a
+  class CMatcher
+    # @!method self.new(condition)
+    #   @param condition [Object] the condition
+    #   @return [Mongory::CMatcher] a new matcher
+    #   @note This method is implemented in the C extension
+    #
+    #   @!method match?(record)
+    #     @param record [Object] the record to match against
+    #     @return [Boolean] true if the record matches the condition, false otherwise
+    #     @note This method is implemented in the C extension
+    #   @!method explain
+    #     @return [void]
+    #     @note This method will print metcher tree structure
+    #     @note This method is implemented in the C extension
+    #   @!method trace
+    #     @return [Boolean] true if the record matches the condition, false otherwise
+    #     @note This method will print matching process
+    #     @note This method is implemented in the C extension
+    #   @!method enable_trace
+    #     @return [void]
+    #     @note This method will enable trace
+    #     @note This method is implemented in the C extension
+    #   @!method disable_trace
+    #     @return [void]
+    #     @note This method will disable trace
+    #     @note This method is implemented in the C extension
+    #   @!method print_trace
+    #     @return [void]
+    #     @note This method will print trace result
+    #     @note This method is implemented in the C extension
+    #   @!method condition
+    #     @return [Object] the condition
+    #     @note This method is implemented in the C extension
+    #   @!method context
+    #     @return [Utils::Context] the context
+    #     @note This method is implemented in the C extension
+    #   @!method trace_result_colorful=
+    #     @param colorful [Boolean] whether to enable colorful trace result
+    #     @return [Boolean]
+    #     @note This method is implemented in the C extension
+
+    # @return [Proc] a Proc that performs the matching operation
+    def to_proc
+      Proc.new { |record| match?(record) }
+    end
+  end
+end

data/lib/mongory/query_builder.rb

@@ -65,10 +65,27 @@ module Mongory
       @matcher.prepare_query
       matcher_block = @matcher.to_proc
       @records.each do |record|
+        @context.current_record = record
         yield record if matcher_block.call(record)
       end
     end
 
+    def trace
+      return to_enum(:trace) unless block_given?
+
+      Mongory.debugger.enable
+      @matcher.prepare_query
+      @records.each do |record|
+        @context.current_record = record
+        matched = @matcher.match?(record)
+        Mongory.debugger.display
+        yield record if matched
+        Mongory.debugger.clear
+      end
+    ensure
+      Mongory.debugger.disable
+    end
+
     # Adds a condition to filter records using the given condition.
     # This is an alias for `and`.
     #

data/lib/mongory/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Mongory
-  VERSION = '0.7.8'
+  VERSION = '0.8.0'
 end

data/lib/mongory.rb

@@ -120,6 +120,7 @@ begin
   abi = RUBY_VERSION.split('.').first(2).join('.')
   require "core/#{abi}/mongory_ext"
   require_relative 'mongory/c_query_builder'
+  require_relative 'mongory/c_matcher'
 rescue LoadError => e
   warn("Mongory C extension is disabled because mongory_ext is not loaded: #{e.message}")
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mongory
 version: !ruby/object:Gem::Version
-  version: 0.7.8
+  version: 0.8.0
 platform: x64-mingw-ucrt
 authors:
 - koten0224
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-08-27 00:00:00.000000000 Z
+date: 2025-08-30 00:00:00.000000000 Z
 dependencies: []
 description: A Mongo-like in-memory query DSL for Ruby
 email:
@@ -88,6 +88,7 @@ files:
 - lib/generators/mongory/matcher/templates/matcher.rb.erb
 - lib/generators/mongory/matcher/templates/matcher_spec.rb.erb
 - lib/mongory.rb
+- lib/mongory/c_matcher.rb
 - lib/mongory/c_query_builder.rb
 - lib/mongory/converters.rb
 - lib/mongory/converters/abstract_converter.rb