mongory 0.7.1 → 0.7.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2a7ec315565b227d1051af4673da4a5e9eab1c91bb3a578b0bef378d7b829a38
-  data.tar.gz: 8d85c987c23b6f4066f8ed3fd752b5ba829e830e75eb3859eb7765bcf999278b
+  metadata.gz: a9e4755140f8dbd9fe0b675d979760c0bdbc005a391702a60f55615616670ac0
+  data.tar.gz: 31584c0ec35cb2ee3e064a7ee0ff20299909ea4ae213bbd7b2bac3bb07cd0a03
 SHA512:
-  metadata.gz: 894bf40d954782890b1793b78f2710f370c964b4fec5cd9e3b453dc9d57bcf102081dee5ea1023e3c59dabe5f37ff09ccb2dde2d5585cbd7c0c6e79b6c115904
-  data.tar.gz: afdc73456ddfec6bce3e326bc1a948293c0e6a844c358cb06130b20678ea9c7c53dc06d2e0e43cfb03cf067a4f3a696938243a5c6af4715efd1a813276300a2e
+  metadata.gz: af4d275a953e7dc08a05f2685ea590e5173f114e149699bd9649accbcaba044fa3146597e3aa01accce89f643f6fc030418f86e6c59a21678728b727645349fe
+  data.tar.gz: 5d2ac8f618111e083e17393eec30a777da4b74a73a3bbc2643818601880e544738223830f538d3048d7e057bd87118d331a4de30f227a931d245afa102449ad8

data/.rubocop.yml

@@ -7,6 +7,8 @@ AllCops:
     - 'tmp/**/*'
     - 'examples/**/*'
     - 'ext/**/*'
+    - 'pkg/**/*'
+    - 'mongory.gemspec'
   TargetRubyVersion: 2.6
 
 Style/StringLiterals:

data/README.md

@@ -51,6 +51,40 @@ Or add to your Gemfile:
 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:
+
+- Debian/Ubuntu (including ruby:*-slim base images)
+```bash
+apt-get update && apt-get install -y build-essential
+```
+
+- Alpine
+```bash
+apk add --no-cache build-base
+```
+
+- CentOS/RHEL
+```bash
+yum groupinstall -y "Development Tools"
+```
+
+- Fedora
+```bash
+dnf groupinstall -y "Development Tools"
+```
+
+- Amazon Linux
+```bash
+yum groupinstall -y "Development Tools"
+```
+
+- macOS
+```bash
+xcode-select --install
+```
+
 #### Rails Generator
 
 You can install a starter configuration with:

data/Rakefile

@@ -1,22 +1,41 @@
 # frozen_string_literal: true
 
+require 'rake/extensiontask'
 require 'bundler/gem_tasks'
-require 'rspec/core/rake_task'
-
-RSpec::Core::RakeTask.new(:spec)
-
-require 'rubocop/rake_task'
+begin
+  require 'rspec/core/rake_task'
+  RSpec::Core::RakeTask.new(:spec)
 
-RuboCop::RakeTask.new
+  require 'rubocop/rake_task'
+  RuboCop::RakeTask.new
+rescue LoadError
+  # When rspec or rubocop is not installed in the CI cross-build environment, the definition of the test task is skipped
+end
 
 # Add support for rake-compiler if available
 begin
-  require 'rake/extensiontask'
+  ENV['RUBY_CC_VERSION'] ||= '2.6.0:2.7.0:3.0.0:3.1.0:3.2.0:3.3.0'
+
+  spec = Gem::Specification.load('mongory.gemspec')
 
-  Rake::ExtensionTask.new('mongory_ext') do |ext|
-    ext.lib_dir = 'ext/mongory_ext'
+  Rake::ExtensionTask.new('mongory_ext', spec) do |ext|
+    abi = RUBY_VERSION.split('.').first(2).join('.')
+    ext.lib_dir = "lib/core/#{abi}"
     ext.ext_dir = 'ext/mongory_ext'
     ext.source_pattern = '*.c'
+    ext.gem_spec = spec
+    ext.cross_compile = true
+    ext.cross_platform = [
+      'x86_64-linux',
+      'aarch64-linux',
+      'x86_64-darwin',
+      'arm64-darwin',
+      # 'arm64-mingw-ucrt', # TODO: add this when we have a mingw-ucrt rake-compiler-dock image
+      'x64-mingw32',
+      'x64-mingw-ucrt',
+      'x86_64-linux-musl',
+      'aarch64-linux-musl'
+    ]
   end
 
   # Add tasks for building with submodule

data/ext/mongory_ext/mongory_ext.c

@@ -71,6 +71,7 @@ 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 = {
   .wrap_struct_name = "mongory_matcher",
@@ -102,8 +103,7 @@ static VALUE ruby_mongory_matcher_new(int argc, VALUE *argv, VALUE class) {
   rb_mongory_matcher_parse_argv(wrapper, argc, argv);
 
   mongory_matcher *matcher = mongory_matcher_new(wrapper->pool, wrapper->condition, wrapper->ctx);
-  if (wrapper->pool->error) {
-    rb_raise(eMongoryTypeError, "Failed to create matcher: %s", wrapper->pool->error->message);
+  if (mongory_error_handling(wrapper->pool, "Failed to create matcher")) {
     return Qnil;
   }
 
@@ -137,14 +137,13 @@ 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;
-  if (wrapper->trace_enabled) {
-    data_value = ruby_to_mongory_value_deep(wrapper->scratch_pool, data);
-  } else {
-    data_value = ruby_to_mongory_value_shallow(wrapper->scratch_pool, data);
+  data_value = ruby_to_mongory_value_shallow(wrapper->scratch_pool, data);
+  if (mongory_error_handling(wrapper->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->ctx);
+    wrapper->scratch_pool->reset(wrapper->scratch_pool);
   }
   return result ? Qtrue : Qfalse;
 }
@@ -154,7 +153,10 @@ 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);
   mongory_matcher_explain(wrapper->matcher, wrapper->scratch_pool);
-  wrapper->scratch_pool->reset(wrapper->scratch_pool->ctx);
+  if (mongory_error_handling(wrapper->scratch_pool, "Explain failed")) {
+    return Qnil;
+  }
+  wrapper->scratch_pool->reset(wrapper->scratch_pool);
   return Qnil;
 }
 
@@ -162,9 +164,12 @@ static VALUE ruby_mongory_matcher_explain(VALUE self) {
 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_deep(wrapper->scratch_pool, data);
+  mongory_value *data_value = ruby_to_mongory_value_shallow(wrapper->scratch_pool, data);
+  if (mongory_error_handling(wrapper->scratch_pool, "Trace failed")) {
+    return Qnil;
+  }
   bool matched = mongory_matcher_trace(wrapper->matcher, data_value);
-  wrapper->scratch_pool->reset(wrapper->scratch_pool->ctx);
+  wrapper->scratch_pool->reset(wrapper->scratch_pool);
   return matched ? Qtrue : Qfalse;
 }
 
@@ -173,6 +178,9 @@ 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")) {
+    return Qnil;
+  }
   wrapper->trace_enabled = true;
   return Qnil;
 }
@@ -182,7 +190,10 @@ 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);
   mongory_matcher_disable_trace(wrapper->matcher);
-  wrapper->scratch_pool->reset(wrapper->scratch_pool->ctx);
+  if (mongory_error_handling(wrapper->scratch_pool, "Disable trace failed")) {
+    return Qnil;
+  }
+  wrapper->scratch_pool->reset(wrapper->scratch_pool);
   wrapper->trace_enabled = false;
   return Qnil;
 }
@@ -192,6 +203,7 @@ 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);
   mongory_matcher_print_trace(wrapper->matcher);
+  mongory_error_handling(wrapper->scratch_pool, "Print trace failed");
   return Qnil;
 }
 
@@ -206,7 +218,14 @@ static VALUE ruby_mongory_matcher_condition(VALUE self) {
 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);
-  return wrapper->ctx == NULL ? Qnil : wrapper->ctx;
+  return wrapper->ctx ? wrapper->ctx : Qnil;
+}
+
+// Mongory::CMatcher.trace_result_colorful=(colorful)
+static VALUE ruby_mongory_matcher_trace_result_colorful(VALUE self, VALUE colorful) {
+  (void)self;
+  mongory_matcher_trace_result_colorful_set(RTEST(colorful));
+  return Qnil;
 }
 
 /**
@@ -255,6 +274,15 @@ static void ruby_mongory_matcher_mark(void *ptr) {
  * Helper functions for Ruby/C conversion
  */
 
+// Helper function to convert Ruby value to C string
+static char *ruby_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);
+  return StringValueCStr(rb_str);
+}
+
+// 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) {
   mongory_value *mg_value = NULL;
   switch (TYPE(rb_value)) {
@@ -333,6 +361,7 @@ mongory_value *ruby_to_mongory_value_shallow(mongory_memory_pool *pool, VALUE rb
   return ruby_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;
@@ -354,6 +383,7 @@ static int hash_foreach_deep_convert_cb(VALUE key, VALUE val, VALUE ptr) {
   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);
   if (mg_value) {
@@ -395,10 +425,12 @@ static mongory_value *ruby_to_mongory_value_deep_rec(mongory_memory_pool *pool,
   return mg_value;
 }
 
+// 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);
 }
 
+// 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;
   VALUE rb_hash = table->rb_hash;
@@ -420,6 +452,7 @@ mongory_value *ruby_mongory_table_get(mongory_table *self, char *key) {
   return ruby_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;
@@ -428,9 +461,13 @@ mongory_value *ruby_mongory_table_wrap(mongory_memory_pool *pool, VALUE rb_hash)
   table->rb_hash = rb_hash;
   table->base.count = RHASH_SIZE(rb_hash);
   table->owner = rb_pool->owner;
-  return mongory_value_wrap_t(pool, &table->base);
+  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;
+  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;
   VALUE rb_array = array->rb_array;
@@ -441,32 +478,22 @@ static mongory_value *ruby_mongory_array_get(mongory_array *self, size_t index)
   return ruby_to_mongory_value_shallow(self->pool, rb_value);
 }
 
-static bool ruby_mongory_array_each(mongory_array *self, void *acc, mongory_array_callback_func func) {
-  ruby_mongory_array_t *array = (ruby_mongory_array_t *)self;
-  VALUE rb_array = array->rb_array;
-  for (long i = 0; i < RARRAY_LEN(rb_array); i++) {
-    VALUE rb_value = rb_ary_entry(rb_array, i);
-    mongory_value *cval = ruby_to_mongory_value_shallow(self->pool, rb_value);
-    if (!func(cval, acc)) {
-      return false;
-    }
-  }
-  return true;
-}
-
+// 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;
   array->base.pool = pool;
   array->base.get = ruby_mongory_array_get;
-  array->base.each = ruby_mongory_array_each;
   array->rb_array = rb_array;
   array->base.count = RARRAY_LEN(rb_array);
   array->owner = rb_pool->owner;
-  return mongory_value_wrap_a(pool, &array->base);
+  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;
+  return mg_value;
 }
 
-// Convert mongory_value to Ruby value
+// Convert mongory_value to Ruby value (returns the original Ruby value where binding in below conversion is needed)
 void *mongory_value_to_ruby(mongory_memory_pool *pool, mongory_value *value) {
   (void)pool;
   if (!value)
@@ -487,12 +514,14 @@ static VALUE cache_fetch_string(ruby_mongory_matcher_t *owner, const char *key)
   return s;
 }
 
+// Helper function to convert char* key to Ruby symbol
 static inline VALUE char_key_to_symbol(const char *key, rb_encoding *enc) {
   ID id = rb_check_id_cstr(key, (long)strlen(key), enc);
   if (!id) id = rb_intern3(key, (long)strlen(key), enc);
   return ID2SYM(id);
 }
 
+// Cache helper for Ruby symbol keys
 static VALUE cache_fetch_symbol(ruby_mongory_matcher_t *owner, const char *key) {
   rb_encoding *enc = rb_utf8_encoding();
   if (!owner || !owner->symbol_map) {
@@ -535,6 +564,7 @@ static bool ruby_regex_match_adapter(mongory_memory_pool *pool, mongory_value *p
   return RTEST(matched);
 }
 
+// Regex adapter bridging to Ruby's Regexp
 static char *ruby_regex_stringify_adapter(mongory_memory_pool *pool, mongory_value *pattern) {
   (void)pool;
   if (pattern->type != MONGORY_TYPE_REGEX) {
@@ -545,6 +575,7 @@ static char *ruby_regex_stringify_adapter(mongory_memory_pool *pool, mongory_val
   return StringValueCStr(rb_str);
 }
 
+// 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) {
   mongory_memory_pool *pool = condition->pool;
   ruby_mongory_memory_pool_t *rb_pool = (ruby_mongory_memory_pool_t *)pool;
@@ -579,17 +610,30 @@ static mongory_matcher_custom_context *ruby_custom_matcher_build(char *key, mong
   return return_ctx;
 }
 
+// Custom matcher adapter bridging to Ruby's custom matcher
 static bool ruby_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) {
   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) {
+  if (pool->error) {
+    rb_raise(eMongoryTypeError, "%s: %s", error_message, pool->error->message);
+    pool->error = NULL;
+    pool->reset(pool);
+    return true;
+  }
+  return false;
+}
+
 /**
  * Extension initialization
  */
@@ -613,6 +657,7 @@ void Init_mongory_ext(void) {
 
   // 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);
@@ -621,13 +666,16 @@ void Init_mongory_ext(void) {
   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);
+
   // 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);
+
   // 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_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);

data/lib/mongory/matchers/in_matcher.rb

@@ -24,12 +24,12 @@ module Mongory
     #
     # @see AbstractMatcher
     class InMatcher < AbstractMatcher
-      def self.build(condition, *args)
+      def self.build(condition, context: Context.new)
         return super unless condition.is_a?(Range)
 
         end_op = condition.exclude_end? ? '$lt' : '$lte'
         head, tail = [condition.first, condition.last].sort
-        AndMatcher.build([{ '$gte' => head }, { end_op => tail }], *args)
+        AndMatcher.build([{ '$gte' => head }, { end_op => tail }], context: context)
       end
 
       # Creates a raw Proc that performs the in-matching operation.

data/lib/mongory/matchers/nin_matcher.rb

@@ -24,12 +24,12 @@ module Mongory
     #
     # @see AbstractMatcher
     class NinMatcher < AbstractMatcher
-      def self.build(condition, *args)
+      def self.build(condition, context: Context.new)
         return super unless condition.is_a?(Range)
 
         end_op = condition.exclude_end? ? '$gte' : '$gt'
         head, tail = [condition.first, condition.last].sort
-        OrMatcher.build([{ '$lt' => head }, { end_op => tail }], *args)
+        OrMatcher.build([{ '$lt' => head }, { end_op => tail }], context: context)
       end
 
       # Creates a raw Proc that performs the not-in matching operation.

data/lib/mongory/version.rb

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

data/lib/mongory.rb

@@ -2,6 +2,7 @@
 
 require 'time'
 require 'date'
+require 'set'
 require 'singleton'
 require_relative 'mongory/version'
 require_relative 'mongory/utils'
@@ -116,8 +117,9 @@ module Mongory
 end
 
 begin
-  require_relative '../ext/mongory_ext/mongory_ext'
+  abi = RUBY_VERSION.split('.').first(2).join('.')
+  require "core/#{abi}/mongory_ext"
   require_relative 'mongory/c_query_builder'
 rescue LoadError
-  Mongory.debugger.warn('Mongory::CQueryBuilder is disabled because mongory_ext is not loaded')
+  warn('Mongory::CQueryBuilder is disabled because mongory_ext is not loaded')
 end

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: mongory
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 0.7.5
 platform: ruby
 authors:
 - koten0224
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-08-17 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: rake-compiler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.0'
+date: 2025-08-26 00:00:00.000000000 Z
+dependencies: []
 description: A Mongo-like in-memory query DSL for Ruby
 email:
 - koten0224@gmail.com
@@ -50,46 +36,6 @@ files:
 - examples/benchmark-rails.rb
 - examples/benchmark.rb
 - ext/mongory_ext/extconf.rb
-- ext/mongory_ext/mongory-core/LICENSE
-- ext/mongory_ext/mongory-core/include/mongory-core.h
-- ext/mongory_ext/mongory-core/include/mongory-core/foundations/array.h
-- ext/mongory_ext/mongory-core/include/mongory-core/foundations/config.h
-- ext/mongory_ext/mongory-core/include/mongory-core/foundations/error.h
-- ext/mongory_ext/mongory-core/include/mongory-core/foundations/memory_pool.h
-- ext/mongory_ext/mongory-core/include/mongory-core/foundations/table.h
-- ext/mongory_ext/mongory-core/include/mongory-core/foundations/value.h
-- ext/mongory_ext/mongory-core/include/mongory-core/matchers/matcher.h
-- ext/mongory_ext/mongory-core/src/foundations/array.c
-- ext/mongory_ext/mongory-core/src/foundations/array_private.h
-- ext/mongory_ext/mongory-core/src/foundations/config.c
-- ext/mongory_ext/mongory-core/src/foundations/config_private.h
-- ext/mongory_ext/mongory-core/src/foundations/error.c
-- ext/mongory_ext/mongory-core/src/foundations/memory_pool.c
-- ext/mongory_ext/mongory-core/src/foundations/string_buffer.c
-- ext/mongory_ext/mongory-core/src/foundations/string_buffer.h
-- ext/mongory_ext/mongory-core/src/foundations/table.c
-- ext/mongory_ext/mongory-core/src/foundations/value.c
-- ext/mongory_ext/mongory-core/src/matchers/array_record_matcher.c
-- ext/mongory_ext/mongory-core/src/matchers/array_record_matcher.h
-- ext/mongory_ext/mongory-core/src/matchers/base_matcher.c
-- ext/mongory_ext/mongory-core/src/matchers/base_matcher.h
-- ext/mongory_ext/mongory-core/src/matchers/compare_matcher.c
-- ext/mongory_ext/mongory-core/src/matchers/compare_matcher.h
-- ext/mongory_ext/mongory-core/src/matchers/composite_matcher.c
-- ext/mongory_ext/mongory-core/src/matchers/composite_matcher.h
-- ext/mongory_ext/mongory-core/src/matchers/existance_matcher.c
-- ext/mongory_ext/mongory-core/src/matchers/existance_matcher.h
-- ext/mongory_ext/mongory-core/src/matchers/external_matcher.c
-- ext/mongory_ext/mongory-core/src/matchers/external_matcher.h
-- ext/mongory_ext/mongory-core/src/matchers/inclusion_matcher.c
-- ext/mongory_ext/mongory-core/src/matchers/inclusion_matcher.h
-- ext/mongory_ext/mongory-core/src/matchers/literal_matcher.c
-- ext/mongory_ext/mongory-core/src/matchers/literal_matcher.h
-- ext/mongory_ext/mongory-core/src/matchers/matcher.c
-- ext/mongory_ext/mongory-core/src/matchers/matcher_explainable.c
-- ext/mongory_ext/mongory-core/src/matchers/matcher_explainable.h
-- ext/mongory_ext/mongory-core/src/matchers/matcher_traversable.c
-- ext/mongory_ext/mongory-core/src/matchers/matcher_traversable.h
 - ext/mongory_ext/mongory_ext.c
 - lib/generators/mongory/install/install_generator.rb
 - lib/generators/mongory/install/templates/initializer.rb.erb
@@ -140,7 +86,6 @@ files:
 - lib/mongory/utils/rails_patch.rb
 - lib/mongory/utils/singleton_builder.rb
 - lib/mongory/version.rb
-- mongory.gemspec
 - scripts/build_with_core.sh
 - sig/mongory.rbs
 homepage: https://mongoryhq.github.io/mongory-rb/
@@ -152,7 +97,7 @@ metadata:
   homepage_uri: https://mongoryhq.github.io/mongory-rb/
   source_code_uri: https://github.com/mongoryhq/mongory-rb
   changelog_uri: https://github.com/mongoryhq/mongory-rb/blob/main/CHANGELOG.md
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -167,8 +112,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
-signing_key: 
+rubygems_version: 3.4.19
+signing_key:
 specification_version: 4
 summary: MongoDB-like in-memory query DSL for Ruby
 test_files: []

data/ext/mongory_ext/mongory-core/LICENSE

@@ -1,3 +0,0 @@
-MIT License
-
-Copyright (c)