mongory 0.4.0 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5eea64a674029abe74c693aeb3c1ded8b35101e7b88f0f435f51a22ae6f254b7
-  data.tar.gz: 96d9c62bf532ba3c8d55d38b6f99667e62fe0143fe196428446da2a23aa678c4
+  metadata.gz: f2e272e3c249c11059ecf96ad8eb0659d5e0fb0157050e7d69b6e272e16f874a
+  data.tar.gz: 84316343470d975672edbed9e590661bf555af5aa6ceb862d4e850efac0f5266
 SHA512:
-  metadata.gz: 0b102c1aebfd8f7117c17cdf791cff88d0c413a3eb66e62968f8cfd72ab261ce5a06c7d7eaf0d7d7f352abc961ecb5aecd96cd8089a5107677fb9fd3c666beb3
-  data.tar.gz: 9cf4b13d971b4ec78b8fc7682c20964aef5b334b88b0d1c09fbd70a7a0b266556ac850c9f71bdf915f723ce414a82313e44d6876a5cd76d1856e1d0f6761c867
+  metadata.gz: f0709d9abd1a769c111cc27b73a25f1d79b2af931de122fad4538259b97eccd5a8bb26336fab68d8affbba830ffa9a8af3bf07323f17051f588c633938a43b75
+  data.tar.gz: 292d65f888d36af1d22a9e4d7973ee8995c055c37abc837b1fdca161f5d4b37ed285c253da7a6019172848cb89d35e76e5ce0fa7b88725272ecdc46718d23968

data/CHANGELOG.md

@@ -1,4 +1,55 @@
 # Changelog
+## [0.6.1] - 2025-04-24
+
+### Major Changes
+- Add size matcher
+- $in and $nin supports range condition
+- Query matcher inherits from Hash condition matcher to accept hash condition only
+- Introduced Converted to mark converted data and prevent double convert
+
+## [0.6.0] - 2025-04-23
+
+### Major Changes
+- Refactored matcher system to use Proc-based implementation
+- Introduced Context system for better state management
+- Optimized empty condition handling with TRUE_PROC and FALSE_PROC
+
+### Breaking Changes
+- Removed `match` method in favor of `raw_proc`
+- Changed converter behavior to be executed within Proc
+- Modified fallback behavior in converters
+
+### Features
+- Added Context system for better configuration management
+- Improved performance with Proc caching
+- Enhanced error handling in matchers
+- Better support for complex query conditions
+
+### Performance
+- Optimized empty condition handling
+- Reduced memory usage with Proc caching
+- Improved execution speed with Proc-based implementation
+
+### Internal
+- Refactored matcher system architecture
+- Improved code organization and maintainability
+- Enhanced test coverage
+
+## [0.5.0] - 2025-04-22
+
+### Added
+- Added fast mode implementation for optimized query performance
+- Added Proc-based matching for efficient record filtering
+- Added error handling in fast mode execution
+
+### Changed
+- Optimized query execution with compiled Proc objects
+- Improved memory efficiency in record matching
+- Enhanced error handling in query execution
+
+### Fixed
+- Fixed potential performance bottlenecks in record matching
+- Fixed error handling in query execution
 
 ## [0.4.0] - 2025-04-20
 

data/README.md

@@ -245,6 +245,22 @@ Internally, the query is compiled into a matcher tree using the `QueryMatcher` a
 | `nin` | Checks if a value is not in a set | `nin(age: [18, 19, 20])` |
 | `limit` | Limits the number of records returned. This method executes immediately and affects subsequent conditions. | `limit(2)` |
 | `pluck` | Extracts selected fields from matching records | `pluck(:name)` |
+| `with_context` | Sets a custom context for the query. Useful for controlling data conversion and sharing configuration across matchers. | `with_context(merchant: merchant)` |
+
+#### Context Configuration
+
+The `with_context` method allows you to customize the query execution environment:
+
+```ruby
+# Share configuration across matchers
+records.mongory
+  .with_context(custom_option: true)
+  .where(:status => 'active')
+  .where(:age.gte => 18)
+```
+
+This will share a mutatable, but stable context object to all matchers in matcher tree.
+To get your custom option, using `@context.config` in your custom matcher.
 
 ### Debugging Queries
 
@@ -313,30 +329,37 @@ The debug output includes:
 1. **Memory Usage**
    - Mongory operates entirely in memory
    - Consider your data size and memory constraints
+   - Proc-based implementation reduces memory usage
+   - Context system provides better memory management
 
 2. **Query Optimization**
    - Complex conditions are evaluated in sequence
    - Use `explain` to analyze query performance
+   - Empty conditions are optimized with cached Procs
+   - Context system allows fine-grained control over conversion
 
 3. **Benchmarks**
   ```ruby
     # Simple query (1000 records)
-    records.mongory.where(:age.gte => 18) # ~2.5ms
+    records.mongory.where(:age.gte => 18) # ~0.8ms
 
     # Complex query (1000 records)
-    records.mongory.where(:$or => [{:age.gte => 18}, {:status => 'active'}]) # ~3.2ms
+    records.mongory.where(:$or => [{:age.gte => 18}, {:status => 'active'}]) # ~0.9ms
 
     # Simple query (10000 records)
-    records.mongory.where(:age.gte => 18) # ~24.5ms
+    records.mongory.where(:age.gte => 18) # ~6.5ms
 
     # Complex query (10000 records)
-    records.mongory.where(:$or => [{:age.gte => 18}, {:status => 'active'}]) # ~31.5ms
+    records.mongory.where(:$or => [{:age.gte => 18}, {:status => 'active'}]) # ~7.5ms
 
     # Simple query (100000 records)
-    records.mongory.where(:age.gte => 18) # ~242.5ms
+    records.mongory.where(:age.gte => 18) # ~64.7ms
 
     # Complex query (100000 records)
-    records.mongory.where(:$or => [{:age.gte => 18}, {:status => 'active'}]) # ~323.0ms
+    records.mongory.where(:$or => [{:age.gte => 18}, {:status => 'active'}]) # ~75.0ms
+
+    # Complex query with fast mode (100000 records)
+    records.mongory.where(:$or => [{:age.gte => 18}, {:status => 'active'}]).fast # ~42.8ms, about 3x of plain ruby
   ```
 
    Note: Performance varies based on:
@@ -435,6 +458,9 @@ end
     # Use limit to restrict result set
     records.mongory.limit(100).where(:age.gte => 18)
 
+    # Use fast mode for better performance
+    records.mongory.where(:age.gte => 18).fast
+
     # Use explain to analyze complex queries
     query = records.mongory.where(:$or => [...])
     query.explain
@@ -457,10 +483,14 @@ end
 1. **Data Size**
    - Suitable for small to medium datasets
    - Large datasets may impact performance
+   - Proc-based implementation helps with memory usage
+   - Context system provides better resource management
 
 2. **Query Complexity**
    - Complex queries may affect performance
    - Not all MongoDB operators are supported
+   - Proc-based implementation improves complex query performance
+   - Context system allows better control over query execution
 
 3. **Memory Usage**
    - All operations are performed in memory
@@ -510,7 +540,7 @@ Please ensure your code adheres to the project's style guide and that all tests
 
 ## Code of Conduct
 
-Everyone interacting in the Mongory-rb project's codebases, issue trackers, chat rooms, and mailing lists is expected to follow the [code of conduct](https://github.com/koten0224/mongory-rb/blob/main/CODE_OF_CONDUCT.md).
+Everyone interacting in the Mongory-rb project's codebases, issue trackers, chat rooms, and mailing lists is expected to follow the [code of conduct](https://github.com/mongoryhq/mongory-rb/blob/main/CODE_OF_CONDUCT.md).
 
 ## License
 

data/examples/benchmark-rails.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'active_support/all'
+require 'benchmark'
+
+puts 'Ruby String#empty?'
+result = Benchmark.measure do
+  1_000_000.times do
+    ''.empty?
+  end
+end
+puts result
+
+puts 'Rails String#blank?'
+result = Benchmark.measure do
+  1_000_000.times do
+    ''.blank?
+  end
+end
+puts result
+
+puts 'Ruby Array#empty?'
+result = Benchmark.measure do
+  1_000_000.times do
+    [].empty?
+  end
+end
+puts result
+
+puts 'Rails Array#blank?'
+result = Benchmark.measure do
+  1_000_000.times do
+    [].blank?
+  end
+end
+puts result
+
+puts 'Ruby Hash#empty?'
+result = Benchmark.measure do
+  1_000_000.times do
+    {}.empty?
+  end
+end
+puts result
+
+puts 'Rails Hash#blank?'
+result = Benchmark.measure do
+  1_000_000.times do
+    {}.blank?
+  end
+end
+puts result

data/examples/benchmark.rb

@@ -7,8 +7,23 @@ require 'benchmark'
 Mongory.register(Array)
 Mongory.enable_symbol_snippets!
 
+def gc_handler
+  # GC.disable
+  before = GC.stat
+  yield
+  after = GC.stat
+  # GC.enable
+
+  created = after[:total_allocated_objects] - before[:total_allocated_objects]
+  freed   = after[:total_freed_objects] - before[:total_freed_objects]
+  alive   = after[:heap_live_slots] - before[:heap_live_slots]
+
+  puts "Created: #{created}"    # 分配了幾個 object
+  puts "Freed: #{freed}"        # 中途 GC 掃掉幾個（若 GC 有觸發）
+  puts "Net alive: #{alive}"    # 最後還活著的物件數
+end
 # Test with different data sizes
-[1000, 10_000, 100_000].each do |size|
+[20, 1000, 10_000, 100_000].each do |size|
   puts "\nTesting with #{size} records:"
 
   # Generate test data
@@ -19,26 +34,72 @@ Mongory.enable_symbol_snippets!
     }
   end
 
-  # Simple query test
-  puts "\nSimple query (#{size} records):"
-  5.times do
-    result = Benchmark.measure do
-      records.mongory.where(:age.gte => 18).to_a
+  # Simple query (Plain Ruby) test
+  puts "\nSimple query (Plain Ruby) (#{size} records):"
+  gc_handler do
+    5.times do
+      result = Benchmark.measure do
+        records.select { |r| r.key?('age') && r['age'] >= 18 }
+      end
+      puts result
+    end
+  end
+
+  # Simple query (Mongory) test
+  puts "\nSimple query (Mongory) (#{size} records):"
+  gc_handler do
+    5.times do
+      result = Benchmark.measure do
+        records.mongory.where(:age.gte => 18).to_a
+      end
+      puts result
+    end
+  end
+
+  # Complex query (Plain Ruby) test
+  puts "\nComplex query (Plain Ruby) (#{size} records):"
+  gc_handler do
+    5.times do
+      result = Benchmark.measure do
+        records.select do |r|
+          next false unless r.key?('age') && r.key?('status')
+
+          r['age'] >= 18 || r['status'] == 'active'
+        end
+      end
+      puts result
+    end
+  end
+
+  # Complex query (Mongory) test
+  puts "\nComplex query (Mongory) (#{size} records):"
+  gc_handler do
+    5.times do
+      result = Benchmark.measure do
+        records.mongory.where(
+          :$or => [
+            { :age.gte => 18 },
+            { status: 'active' }
+          ]
+        ).to_a
+      end
+      puts result
     end
-    puts result
   end
 
-  # Complex query test
-  puts "\nComplex query (#{size} records):"
-  5.times do
-    result = Benchmark.measure do
-      records.mongory.where(
-        :$or => [
-          { :age.gte => 18 },
-          { status: 'active' }
-        ]
-      ).to_a
+  # Complex query (Mongory) test
+  puts "\nComplex query (Mongory) fast mode (#{size} records):"
+  gc_handler do
+    5.times do
+      result = Benchmark.measure do
+        records.mongory.where(
+          :$or => [
+            { :age.gte => 18 },
+            { status: 'active' }
+          ]
+        ).fast.to_a
+      end
+      puts result
     end
-    puts result
   end
 end

data/lib/generators/mongory/matcher/matcher_generator.rb

@@ -14,7 +14,7 @@ module Mongory
     #   #   spec/mongory/matchers/class_in_matcher_spec.rb
     #   #   config/initializers/mongory.rb (if not exists)
     #
-    # @see Mongory::Matchers::AbstractOperatorMatcher
+    # @see Mongory::Matchers::AbstractMatcher
     class MatcherGenerator < Rails::Generators::NamedBase
       source_root File.expand_path('templates', __dir__)
 

data/lib/mongory/converters/abstract_converter.rb

@@ -33,8 +33,7 @@ module Mongory
       def initialize
         super(self.class.to_s)
         @registries = []
-        @fallback = Proc.new { |*| self }
-        execute_once_only!(:default_registrations)
+        @convert_strategy_map = {}.compare_by_identity
       end
 
       # Applies the registered conversion to the given target object.
@@ -43,27 +42,32 @@ module Mongory
       # @param other [Object] optional secondary value
       # @return [Object] converted result
       def convert(target, other = NOTHING)
-        @registries.each do |registry|
-          next unless target.is_a?(registry.klass)
+        convert_strategy = @convert_strategy_map[target.class] ||= find_strategy(target)
 
-          return exec_convert(target, other, &registry.exec)
-        end
+        return fallback(target, other) if convert_strategy == NOTHING
+        return target.instance_exec(&convert_strategy) if other == NOTHING
+
+        target.instance_exec(other, &convert_strategy)
+      end
 
-        exec_convert(target, other, &@fallback)
+      def fallback(target, _)
+        target
       end
 
-      # Internal dispatch logic to apply a matching converter.
+      # Finds the appropriate conversion strategy for the target object.
+      # Searches through registered rules and returns the first matching one,
+      # or the fallback strategy if no match is found.
       #
-      # @param target [Object] the object to match
-      # @param other [Object] optional extra data
-      # @yield fallback block if no converter is found
-      # @return [Object]
-      def exec_convert(target, other, &block)
-        if other == NOTHING
-          target.instance_exec(&block)
-        else
-          target.instance_exec(other, &block)
+      # @param target [Object] the object to find a strategy for
+      # @return [Proc] the conversion strategy to use
+      def find_strategy(target)
+        @registries.each do |registry|
+          next unless target.is_a?(registry.klass)
+
+          return registry.exec
         end
+
+        NOTHING
       end
 
       # Opens a configuration block to register more converters.
@@ -98,25 +102,11 @@ module Mongory
           register(klass) { |*args, &bl| send(converter, *args, &bl) }
         elsif block.is_a?(Proc)
           @registries.unshift(Registry.new(klass, block))
+          @convert_strategy_map[klass] = block
         else
           raise 'Support Symbol and block only.'
         end
       end
-
-      # Executes the given method only once by undefining it after execution.
-      #
-      # @param method_sym [Symbol] method name to execute once
-      # @return [void]
-      def execute_once_only!(method_sym)
-        send(method_sym)
-        singleton_class.undef_method(method_sym)
-      end
-
-      # Defines default class-to-converter registrations.
-      # Should be overridden by subclasses.
-      #
-      # @return [void]
-      def default_registrations; end
     end
   end
 end

data/lib/mongory/converters/condition_converter.rb

@@ -16,36 +16,27 @@ module Mongory
     #
     class ConditionConverter < AbstractConverter
       # Converts a flat condition hash into a nested structure.
+      # Applies both key and value conversion, and merges overlapping keys.
       #
-      # @param condition [Hash]
+      # @param condition [Hash] the flat condition hash to convert
       # @return [Hash] the transformed nested condition
       def convert(condition)
-        result = {}
+        return condition if condition.is_a?(Converted)
+
+        result = Converted::Hash.new
         condition.each_pair do |k, v|
           converted_value = value_converter.convert(v)
           converted_pair = key_converter.convert(k, converted_value)
-          result.merge!(converted_pair, &deep_merge_block)
+          result.deep_merge!(converted_pair)
         end
-        result
-      end
 
-      # Provides a block that merges values for overlapping keys in a deep way.
-      #
-      # @return [Proc]
-      def deep_merge_block
-        @deep_merge_block ||= Proc.new do |_, a, b|
-          if a.is_a?(Hash) && b.is_a?(Hash)
-            a.merge(b, &deep_merge_block)
-          else
-            b
-          end
-        end
+        result
       end
 
       # @note Singleton instance, not configurable after initialization
       # Returns the key converter used to transform condition keys.
       #
-      # @return [AbstractConverter]
+      # @return [AbstractConverter] the key converter instance
       def key_converter
         KeyConverter.instance
       end
@@ -62,13 +53,12 @@ module Mongory
       #
       # @return [void]
       def freeze
-        deep_merge_block
         super
         key_converter.freeze
         value_converter.freeze
       end
 
-      undef_method :register, :exec_convert
+      undef_method :register
     end
   end
 end

data/lib/mongory/converters/converted.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Mongory
+  module Converters
+    # Converted is a module that provides conversion structures marked as
+    # Converted. It is used to convert various types of data into a
+    # standardized form for MongoDB queries. The module includes
+    # classes for converting hashes and arrays into nested structures.
+    # It is used internally by the ConditionConverter and ValueConverter
+    # to handle the conversion of complex data types into a format
+    # suitable for MongoDB queries.
+    module Converted
+      def instance_convert(other)
+        return other if other.is_a?(Converted)
+
+        case other
+        when Hash
+          Converted::Hash.new(other)
+        when Array
+          Converted::Array.new(other)
+        else
+          other
+        end
+      end
+
+      # Converts a flat condition hash into a nested structure.
+      # Applies value conversion to each element.
+      # This is used for conditions that are hashes of values.
+      # It is used internally by the ConditionConverter and ValueConverter
+      # to handle the conversion of complex data types into a format
+      # suitable for MongoDB queries.
+      class Hash < ::Hash
+        include Converted
+
+        def initialize(other = {})
+          super()
+          other.each_pair do |k, v|
+            self[k] = instance_convert(v)
+          end
+        end
+
+        def deep_merge(other)
+          dup.deep_merge!(Hash.new(other))
+        end
+
+        def deep_merge!(other)
+          _deep_merge!(self, Hash.new(other))
+        end
+
+        private
+
+        def _deep_merge!(left, right)
+          left.merge!(right) do |_, a, b|
+            if a.is_a?(::Hash) && b.is_a?(::Hash)
+              _deep_merge!(a.dup, b)
+            else
+              b
+            end
+          end
+        end
+      end
+
+      # Converts a flat condition array into a nested structure.
+      # Applies value conversion to each element.
+      # This is used for conditions that are arrays of values.
+      # It is used internally by the ConditionConverter and ValueConverter
+      # to handle the conversion of complex data types into a format
+      # suitable for MongoDB queries.
+      class Array < ::Array
+        include Converted
+
+        def initialize(other)
+          super()
+          other.each do |v|
+            self << instance_convert(v)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongory/converters/data_converter.rb

@@ -13,13 +13,24 @@ module Mongory
     #   DataConverter.instance.convert(:status) #=> "status"
     #
     class DataConverter < AbstractConverter
-      def default_registrations
-        register(Symbol, :to_s)
-        register(Date, :to_s)
-        register(Time, :iso8601)
-        register(DateTime, :iso8601)
-        register(String, :itself)
-        register(Integer, :itself)
+      alias_method :super_convert, :convert
+
+      # Converts a value into its standardized form based on its type.
+      # Handles common primitive types with predefined conversion rules.
+      #
+      # @param target [Object] the value to convert
+      # @return [Object] the converted value
+      def convert(target)
+        case target
+        when String, Integer, Hash, Array
+          target
+        when Symbol, Date
+          target.to_s
+        when Time, DateTime
+          target.iso8601
+        else
+          super_convert(target)
+        end
       end
     end
   end