mongory 0.6.0 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c030da605cb94ba20f4be31a03e37a5b95277b1c2b93b48622080521752acbfa
-  data.tar.gz: 3577f0da8e823b74fa25459bb0a66dcb2609ff1eef366ae0ce08402a22d8c049
+  metadata.gz: f2e272e3c249c11059ecf96ad8eb0659d5e0fb0157050e7d69b6e272e16f874a
+  data.tar.gz: 84316343470d975672edbed9e590661bf555af5aa6ceb862d4e850efac0f5266
 SHA512:
-  metadata.gz: 723cdce8afcd41e7f69148934890ac3bc133e297bda01e412b69e491ece2fdfe1b8b27c87244c6417ce4905d18fb8d3082b4217c979b2f6ec1e65bcc71ec0091
-  data.tar.gz: eaa426a3780cc094c0dfd0e5e168fbce4c94db61f504fefa1a44efed5d569bc76a6caf348f5170c46c92916b0ceb384105757b72cbb43e96fdc16208abf7715f
+  metadata.gz: f0709d9abd1a769c111cc27b73a25f1d79b2af931de122fad4538259b97eccd5a8bb26336fab68d8affbba830ffa9a8af3bf07323f17051f588c633938a43b75
+  data.tar.gz: 292d65f888d36af1d22a9e4d7973ee8995c055c37abc837b1fdca161f5d4b37ed285c253da7a6019172848cb89d35e76e5ce0fa7b88725272ecdc46718d23968

data/CHANGELOG.md

@@ -1,4 +1,11 @@
 # 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
 

data/lib/mongory/converters/condition_converter.rb

@@ -21,28 +21,16 @@ module Mongory
       # @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.
-      # When both values are hashes, recursively merges them.
-      # Otherwise, uses the second value.
-      #
-      # @return [Proc] a block for deep merging hash values
-      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
@@ -65,7 +53,6 @@ module Mongory
       #
       # @return [void]
       def freeze
-        deep_merge_block
         super
         key_converter.freeze
         value_converter.freeze

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/value_converter.rb

@@ -26,10 +26,10 @@ module Mongory
       # @return [Object] the converted value
       def convert(target)
         case target
-        when String, Integer, Regexp
+        when String, Integer, Regexp, Converted
           target
         when Array
-          target.map { |x| convert(x) }
+          Converted::Array.new(target.map { |x| convert(x) })
         when Hash
           condition_converter.convert(target)
         else

data/lib/mongory/converters.rb

@@ -5,3 +5,4 @@ require_relative 'converters/condition_converter'
 require_relative 'converters/data_converter'
 require_relative 'converters/key_converter'
 require_relative 'converters/value_converter'
+require_relative 'converters/converted'

data/lib/mongory/matchers/hash_condition_matcher.rb

@@ -72,6 +72,12 @@ module Mongory
           end
         end
       end
+
+      def check_validity!
+        return super if @condition.is_a?(Hash)
+
+        raise TypeError, 'condition needs a Hash.'
+      end
     end
   end
 end

data/lib/mongory/matchers/in_matcher.rb

@@ -33,6 +33,8 @@ module Mongory
 
         Proc.new do |record|
           if record.is_a?(Array)
+            return false if condition.is_a?(Range)
+
             is_present?(condition & record)
           else
             condition.include?(record)
@@ -40,12 +42,15 @@ module Mongory
         end
       end
 
-      # Ensures the condition is an array.
+      # Ensures the condition is an array or range.
       #
-      # @raise [TypeError] if condition is not an array
+      # @raise [TypeError] if condition is not an array nor a range
       # @return [void]
       def check_validity!
-        raise TypeError, '$in needs an array' unless @condition.is_a?(Array)
+        return if @condition.is_a?(Array)
+        return if @condition.is_a?(Range)
+
+        raise TypeError, '$in needs an array or range'
       end
     end
 

data/lib/mongory/matchers/nin_matcher.rb

@@ -33,6 +33,8 @@ module Mongory
 
         Proc.new do |record|
           if record.is_a?(Array)
+            return true if condition.is_a?(Range)
+
             is_blank?(condition & record)
           else
             !condition.include?(record)
@@ -40,12 +42,15 @@ module Mongory
         end
       end
 
-      # Ensures the condition is a valid array.
+      # Ensures the condition is a valid array or range.
       #
-      # @raise [TypeError] if the condition is not an array
+      # @raise [TypeError] if the condition is not an array nor a range
       # @return [void]
       def check_validity!
-        raise TypeError, '$nin needs an array' unless @condition.is_a?(Array)
+        return if @condition.is_a?(Array)
+        return if @condition.is_a?(Range)
+
+        raise TypeError, '$nin needs an array'
       end
     end
 

data/lib/mongory/matchers/size_matcher.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Mongory
+  module Matchers
+    # Matcher for the `$size` operator.
+    #
+    # This matcher expects the input to be an array, and delegates the comparison
+    # to a literal matcher using the array's size as the value.
+    #
+    # For example, the condition `{ tags: { '$size' => 3 } }` will match any
+    # document where `tags` is an array of length 3.
+    #
+    # ### Supported compound usages:
+    #
+    # ```ruby
+    # Mongory.where(tags: { '$size' => 3 })                       # exactly 3 elements
+    # Mongory.where(tags: { '$size' => { '$gt' => 1 } })          # more than 1
+    # Mongory.where(comments: { '$size' => { '$gt' => 1, '$lte' => 5 } })     # more than 1, up to 5 elements
+    # Mongory.where(tags: { '$size' => { '$in' => [1, 2, 3] } })  # 1, 2, or 3 elements
+    # ```
+    #
+    # @see LiteralMatcher
+    #
+    # @note Ruby's Symbol class already defines a `#size` method,
+    #       that will return the size of the symbol object.
+    #       So, this is the only operator that cannot be used with
+    #       the symbol snippet syntax (e.g. `:tags.size`).
+    #
+    #       Use string key syntax instead: `:"tags.$size" => ...`
+    class SizeMatcher < LiteralMatcher
+      # Creates a raw Proc that performs the size matching operation.
+      #
+      # The returned Proc checks if the input is an Array. If so, it calculates
+      # the array's size and passes it to the wrapped literal matcher Proc.
+      #
+      # @return [Proc] A proc that performs size-based matching
+      def raw_proc
+        super_proc = super
+
+        Proc.new do |record|
+          next false unless record.is_a?(Array)
+
+          super_proc.call(record.size)
+        end
+      end
+    end
+
+    register(:size, '$size', SizeMatcher)
+  end
+end

data/lib/mongory/matchers.rb

@@ -173,3 +173,4 @@ require_relative 'matchers/not_matcher'
 require_relative 'matchers/or_matcher'
 require_relative 'matchers/present_matcher'
 require_relative 'matchers/regex_matcher'
+require_relative 'matchers/size_matcher'

data/lib/mongory/query_builder.rb

@@ -228,7 +228,7 @@ module Mongory
     # @param conditions [Array<Hash>] the conditions to add
     # @return [void]
     def add_conditions(key, conditions)
-      condition_dup = @matcher.condition.dup
+      condition_dup = {}.merge!(@matcher.condition)
       condition_dup[key] ||= []
       condition_dup[key] += conditions
       set_matcher(condition_dup)

data/lib/mongory/query_matcher.rb

@@ -28,7 +28,7 @@ module Mongory
   #
   # @see Matchers::LiteralMatcher
   # @see Converters::ConditionConverter
-  class QueryMatcher < Matchers::LiteralMatcher
+  class QueryMatcher < Matchers::HashConditionMatcher
     # Initializes a new query matcher with the given condition.
     # The condition is converted using Mongory.condition_converter
     # before being passed to the parent matcher.

data/lib/mongory/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mongory
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.6.1
 platform: ruby
 authors:
 - koten0224
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2025-04-23 00:00:00.000000000 Z
+date: 2025-04-24 00:00:00.000000000 Z
 dependencies: []
 description: A Mongo-like in-memory query DSL for Ruby
 email:
@@ -37,6 +37,7 @@ files:
 - lib/mongory/converters.rb
 - lib/mongory/converters/abstract_converter.rb
 - lib/mongory/converters/condition_converter.rb
+- lib/mongory/converters/converted.rb
 - lib/mongory/converters/data_converter.rb
 - lib/mongory/converters/key_converter.rb
 - lib/mongory/converters/value_converter.rb
@@ -63,6 +64,7 @@ files:
 - lib/mongory/matchers/or_matcher.rb
 - lib/mongory/matchers/present_matcher.rb
 - lib/mongory/matchers/regex_matcher.rb
+- lib/mongory/matchers/size_matcher.rb
 - lib/mongory/mongoid.rb
 - lib/mongory/query_builder.rb
 - lib/mongory/query_matcher.rb