parse-stack-next 5.7.6 → 5.8.1

data/lib/parse/query/constraints.rb

@@ -64,12 +64,37 @@ module Parse
   end
 
   class Constraint
+    # @!visibility private
+    # The constraint value as a list for the array operators (`$in`, `$nin`,
+    # `$all`, `$containedBy`). A Set or a finite Range is expanded into its
+    # members; before, it was wrapped as a single element (`[Set[1, 2]]`,
+    # `["1..3"]`) and matched nothing. A Range that cannot be enumerated
+    # (endless, beginless, or Float bounds) raises ArgumentError; use
+    # `:field.between` for a numeric interval.
+    # @return [Array]
+    def list_value
+      raw = @value
+      if raw.is_a?(Set)
+        raw = raw.to_a
+      elsif raw.is_a?(Range)
+        unless raw.begin.respond_to?(:succ) && !raw.end.nil?
+          raise ArgumentError,
+                "Cannot expand #{raw.inspect} into a list for #{key}. " \
+                "Pass an Array, or use :field.between for an interval."
+        end
+        raw = raw.to_a
+      end
+      val = self.class.formatted_value(raw)
+      val = [val].compact unless val.is_a?(Array)
+      val
+    end
+
     # A constraint for matching by a specific objectId value.
     #
     #  # where this Parse object equals the object in the column `field`.
     #  q.where :field => Parse::Pointer("Field", "someObjectId")
     #  # alias, shorthand when we infer `:field` maps to `Field` parse class.
-    #  q.where :field.id => "someObjectId"
+    #  q.where :field.pointer_id => "someObjectId"
     #  # "field":{"__type":"Pointer","className":"Field","objectId":"someObjectId"}}
     #
     #  class Artist < Parse::Object
@@ -89,19 +114,21 @@ module Parse
     # You can use the objectId in the query as follows:
     #
     #  # shorthand if you are using convention. Will infer class `Artist`
-    #  Song.all :artist.id => artist_id
+    #  Song.all :artist.pointer_id => artist_id
     #
     #  # other approaches, same result
-    #  Song.all :artist.id => artist # safely supported Parse::Pointer
+    #  Song.all :artist.pointer_id => artist # safely supported Parse::Pointer
     #  Song.all :artist => Artist.pointer(artist_id)
     #  Song.all :artist => Parse::Pointer.new("Artist", artist_id)
     #
     class ObjectIdConstraint < Constraint
-      # @!method id
-      # A registered method on a symbol to create the constraint.
+      # @!method pointer_id
+      # A registered method on a symbol to create the constraint. The
+      # operator is registered as `:id` and installed on `Symbol` as
+      # `pointer_id`.
       # @example
-      #  q.where :field.id => "someObjectId"
-      #  q.where :field.id => pointer # safely supported
+      #  q.where :field.pointer_id => "someObjectId"
+      #  q.where :field.pointer_id => pointer # safely supported
       # @return [ObjectIdConstraint]
       register :id
 
@@ -396,8 +423,7 @@ module Parse
 
       # @return [Hash] the compiled constraint.
       def build
-        val = formatted_value
-        val = [val].compact unless val.is_a?(Array)
+        val = list_value
 
         # Convert Parse objects to pointers for array contains queries
         if val.is_a?(Array)
@@ -447,8 +473,7 @@ module Parse
 
       # @return [Hash] the compiled constraint.
       def build
-        val = formatted_value
-        val = [val].compact unless val.is_a?(Array)
+        val = list_value
 
         # Convert Parse objects to pointers for array contains queries
         if val.is_a?(Array)
@@ -493,8 +518,7 @@ module Parse
 
       # @return [Hash] the compiled constraint.
       def build
-        val = formatted_value
-        val = [val].compact unless val.is_a?(Array)
+        val = list_value
         { @operation.operand => { key => val } }
       end
     end
@@ -522,8 +546,7 @@ module Parse
 
       # @return [Hash] the compiled constraint.
       def build
-        val = formatted_value
-        val = [val].compact unless val.is_a?(Array)
+        val = list_value
         { @operation.operand => { key => val } }
       end
     end
@@ -533,18 +556,18 @@ module Parse
     # MongoDB aggregation pipeline with $expr and $size to check array length.
     #
     #  # Exact size match
-    #  q.where :field.size => 2
-    #  q.where :tags.size => 5
+    #  q.where :field.array_size => 2
+    #  q.where :tags.array_size => 5
     #
     #  # Comparison operators via hash
-    #  q.where :tags.size => { gt: 3 }      # size > 3
-    #  q.where :tags.size => { gte: 2 }     # size >= 2
-    #  q.where :tags.size => { lt: 5 }      # size < 5
-    #  q.where :tags.size => { lte: 4 }     # size <= 4
-    #  q.where :tags.size => { ne: 0 }      # size != 0
+    #  q.where :tags.array_size => { gt: 3 }      # size > 3
+    #  q.where :tags.array_size => { gte: 2 }     # size >= 2
+    #  q.where :tags.array_size => { lt: 5 }      # size < 5
+    #  q.where :tags.array_size => { lte: 4 }     # size <= 4
+    #  q.where :tags.array_size => { ne: 0 }      # size != 0
     #
     #  # Combine for range
-    #  q.where :tags.size => { gte: 2, lt: 10 }  # 2 <= size < 10
+    #  q.where :tags.array_size => { gte: 2, lt: 10 }  # 2 <= size < 10
     #
     # @note This constraint uses aggregation pipeline because Parse Server
     #   does not support the $size query operator natively.
@@ -556,11 +579,13 @@ module Parse
     # @see ContainsAllConstraint
     # @see ArraySetEqualsConstraint
     class ArraySizeConstraint < Constraint
-      # @!method size
-      # A registered method on a symbol to create the constraint.
+      # @!method array_size
+      # A registered method on a symbol to create the constraint. The
+      # operator is registered as `:size` and installed on `Symbol` as
+      # `array_size`.
       # @example
-      #  q.where :field.size => 2
-      #  q.where :field.size => { gt: 3, lte: 10 }
+      #  q.where :field.array_size => 2
+      #  q.where :field.array_size => { gt: 3, lte: 10 }
       # @return [ArraySizeConstraint]
       register :size
 
@@ -864,8 +889,7 @@ module Parse
 
       # @return [Hash] the compiled constraint using aggregation pipeline.
       def build
-        val = formatted_value
-        val = [val].compact unless val.is_a?(Array)
+        val = list_value
 
         field_name = Parse::Query.format_field(@operation.operand)
 
@@ -960,8 +984,7 @@ module Parse
 
       # @return [Hash] the compiled constraint using aggregation pipeline.
       def build
-        val = formatted_value
-        val = [val].compact unless val.is_a?(Array)
+        val = list_value
 
         field_name = Parse::Query.format_field(@operation.operand)
 
@@ -1050,8 +1073,7 @@ module Parse
 
       # @return [Hash] the compiled constraint using aggregation pipeline.
       def build
-        val = formatted_value
-        val = [val].compact unless val.is_a?(Array)
+        val = list_value
 
         field_name = Parse::Query.format_field(@operation.operand)
 
@@ -1140,8 +1162,7 @@ module Parse
 
       # @return [Hash] the compiled constraint using aggregation pipeline.
       def build
-        val = formatted_value
-        val = [val].compact unless val.is_a?(Array)
+        val = list_value
 
         field_name = Parse::Query.format_field(@operation.operand)
 
@@ -1307,8 +1328,7 @@ module Parse
 
       # @return [Hash] the compiled constraint using aggregation pipeline.
       def build
-        val = formatted_value
-        val = [val].compact unless val.is_a?(Array)
+        val = list_value
 
         field_name = Parse::Query.format_field(@operation.operand)
 
@@ -1568,10 +1588,10 @@ module Parse
           unless query.is_a?(Parse::Query)
             raise ArgumentError, "Invalid Parse::Query object provided in :query field of value: #{@operation.operand}.#{$dontSelect} => #{@value}"
           end
-          query = query.compile(encode: false, includeClassName: true)
+          query = query.compile_subquery
         elsif @value.is_a?(Parse::Query)
           # if its a query, then assume dontSelect key is the same name as operand.
-          query = @value.compile(encode: false, includeClassName: true)
+          query = @value.compile_subquery
         else
           raise ArgumentError, "Invalid `:select` query constraint. It should follow the format: :field.select => { key: 'key', query: '<Parse::Query>' }"
         end
@@ -1619,10 +1639,10 @@ module Parse
           unless query.is_a?(Parse::Query)
             raise ArgumentError, "Invalid Parse::Query object provided in :query field of value: #{@operation.operand}.#{$dontSelect} => #{@value}"
           end
-          query = query.compile(encode: false, includeClassName: true)
+          query = query.compile_subquery
         elsif @value.is_a?(Parse::Query)
           # if its a query, then assume dontSelect key is the same name as operand.
-          query = @value.compile(encode: false, includeClassName: true)
+          query = @value.compile_subquery
         else
           raise ArgumentError, "Invalid `:reject` query constraint. It should follow the format: :field.reject => { key: 'key', query: '<Parse::Query>' }"
         end
@@ -2269,10 +2289,10 @@ module Parse
           unless query.is_a?(Parse::Query)
             raise ArgumentError, "Invalid Parse::Query object provided in :query field of value: #{@operation.operand}.matches_key_in_query => #{@value}"
           end
-          query = query.compile(encode: false, includeClassName: true)
+          query = query.compile_subquery
         elsif @value.is_a?(Parse::Query)
           # if its a query, then assume key is the same name as operand.
-          query = @value.compile(encode: false, includeClassName: true)
+          query = @value.compile_subquery
         else
           raise ArgumentError, "Invalid `:matches_key_in_query` query constraint. It should follow the format: :field.matches_key_in_query => { key: 'key', query: '<Parse::Query>' }"
         end
@@ -2319,10 +2339,10 @@ module Parse
           unless query.is_a?(Parse::Query)
             raise ArgumentError, "Invalid Parse::Query object provided in :query field of value: #{@operation.operand}.does_not_match_key_in_query => #{@value}"
           end
-          query = query.compile(encode: false, includeClassName: true)
+          query = query.compile_subquery
         elsif @value.is_a?(Parse::Query)
           # if its a query, then assume key is the same name as operand.
-          query = @value.compile(encode: false, includeClassName: true)
+          query = @value.compile_subquery
         else
           raise ArgumentError, "Invalid `:does_not_match_key_in_query` query constraint. It should follow the format: :field.does_not_match_key_in_query => { key: 'key', query: '<Parse::Query>' }"
         end
@@ -3085,16 +3105,20 @@ module Parse
         target_field = @value[:field]
         local_field = @operation.operand
 
-        # Format field names according to Parse conventions
-        # Pointer fields in MongoDB are stored with _p_ prefix
-        formatted_through = "_p_" + Parse::Query.format_field(through_field)
-        formatted_target = "_p_" + Parse::Query.format_field(target_field)
-        formatted_local = "_p_" + Parse::Query.format_field(local_field)
-
         # Determine the target collection name from the through field
         # Use classify to convert field name to class name (e.g., :project -> "Project")
         target_collection = through_field.to_s.classify
 
+        # Format field names according to Parse conventions
+        # Pointer fields in MongoDB are stored with _p_ prefix. The local and
+        # through fields are columns of the queried class; the target field is
+        # a column of the linked class, so it uses that class's names.
+        formatted_through = "_p_" + Parse::Query.format_field(through_field)
+        formatted_target = "_p_" + Parse::Query.with_field_aliases(target_collection) do
+          Parse::Query.format_field(target_field)
+        end
+        formatted_local = "_p_" + Parse::Query.format_field(local_field)
+
         # Build the aggregation pipeline
         # Use clean alias name without _p_ prefix for readability
         lookup_alias = "#{through_field.to_s.camelize(:lower)}_data"
@@ -3168,15 +3192,20 @@ module Parse
         through_field = @value[:through]
         target_field = @value[:field]
 
-        # Convert field names to Parse format (snake_case to camelCase) with _p_ prefix for pointers
-        local_field_name = format_field_name(@operation.operand, is_pointer: true)
-        through_field_name = format_field_name(through_field, is_pointer: true)
-        target_field_name = format_field_name(target_field, is_pointer: true)
-
         # Determine the collection name for the lookup (Rails pluralization)
         through_class_name = through_field.to_s.classify
         lookup_collection = through_class_name
 
+        # Convert field names to Parse format with _p_ prefix for pointers.
+        # The local and through fields are columns of the queried class; the
+        # target field is a column of the linked class, so it uses that
+        # class's names.
+        local_field_name = format_field_name(@operation.operand, is_pointer: true)
+        through_field_name = format_field_name(through_field, is_pointer: true)
+        target_field_name = Parse::Query.with_field_aliases(lookup_collection) do
+          format_field_name(target_field, is_pointer: true)
+        end
+
         # Generate unique alias name for the joined data (use clean name without _p_ prefix)
         lookup_alias = "#{through_field.to_s.camelize(:lower)}_data"
 
@@ -3229,13 +3258,14 @@ module Parse
 
       private
 
-      # Converts field names from snake_case to camelCase for Parse Server compatibility
-      # and adds _p_ prefix for pointer fields in MongoDB
+      # Formats a field name with {Parse::Query.format_field} (so declared
+      # `field:` names in the current alias scope are honored) and adds the
+      # _p_ prefix for pointer fields in MongoDB.
       # @param field [Symbol, String] the field name to format
       # @param is_pointer [Boolean] whether this field is a pointer field
       # @return [String] the formatted field name
       def format_field_name(field, is_pointer: true)
-        formatted = field.to_s.camelize(:lower)
+        formatted = Parse::Query.format_field(field)
         # Add _p_ prefix for pointer fields as they're stored that way in MongoDB
         is_pointer ? "_p_#{formatted}" : formatted
       end

data/lib/parse/query/cursor.rb

@@ -365,7 +365,9 @@ module Parse
     # Returns: (field < last_value) OR (field = last_value AND objectId < last_id)
     # for descending order, or the inverse for ascending.
     def build_cursor_constraint
-      formatted_field = Parse::Query.format_field(@order_field)
+      formatted_field = Parse::Query.with_field_aliases(@query.table) do
+        Parse::Query.format_field(@order_field)
+      end
 
       if @order_direction == :desc
         # Descending: (field < last_value) OR (field = last_value AND objectId < last_id)

data/lib/parse/query/operation.rb

@@ -10,7 +10,8 @@ module Parse
   # queries. It contains an operand (the Parse field) and an operator (the Parse
   # operation). These combined with a value, provide you with a constraint.
   #
-  # All operation registrations add methods to the Symbol class.
+  # All operation registrations add methods to the Symbol class, through
+  # the {Operation::SymbolMethods} module.
   class Operation
 
     # @!attribute operand
@@ -87,18 +88,71 @@ module Parse
       handler.new(self, value)
     end
 
+    # Operator names that are never installed as `Symbol` methods because
+    # they would replace or shadow behavior other code relies on:
+    #
+    # - `:size` is Ruby's own `Symbol#size`; replacing it broke
+    #   `sort_by(&:size)` and any code that measures a symbol.
+    # - `:id` makes every symbol `respond_to?(:id)`, which ActiveRecord
+    #   treats as a record. `where(status: :draft)` then raised
+    #   `TypeError: can't cast Parse::Operation` (issue #83).
+    #
+    # Each one is installed under the alternate name given here instead.
+    # The original name stays registered in {operators}, so an explicit
+    # `Parse::Operation.new(:tags, :size)` still resolves.
+    SYMBOL_METHOD_RENAMES = { id: :pointer_id, size: :array_size }.freeze
+
+    # The module that carries the query DSL methods (`:plays.gt`,
+    # `:tags.in`, ...). It is included into `Symbol` rather than defining
+    # methods on `Symbol` directly, so a method another library defines on
+    # `Symbol` (Mongoid's `Symbol#gt`, Sequel's `Symbol#desc`) is never
+    # replaced by Parse, whichever library loads first.
+    module SymbolMethods; end
+
+    class << self
+      # Operator names that were not installed on `Symbol` because another
+      # library already defines a method of that name. Use the explicit
+      # form `Parse::Operation.new(:field, :op) => value` for these.
+      # @return [Array<Symbol>]
+      def symbol_conflicts
+        @symbol_conflicts ||= []
+      end
+    end
+
     # Register a new symbol operator method mapped to a specific {Parse::Constraint}.
+    # @param op [Symbol] the operator name.
+    # @param klass [Class] the {Parse::Constraint} subclass that handles it.
     def self.register(op, klass)
-      Operation.operators[op.to_sym] = klass
-      # Some operator names (e.g. :size) collide with existing Symbol methods.
-      # The override is intentional - the query DSL repurposes these for
-      # constraint building. Remove the prior definition so define_method
-      # does not emit "method redefined" under ruby -W.
-      Symbol.send(:remove_method, op) if Symbol.method_defined?(op, false)
-      Symbol.send :define_method, op do |value = nil|
+      op = op.to_sym
+      Operation.operators[op] = klass
+      method_name = SYMBOL_METHOD_RENAMES.fetch(op, op)
+      Operation.operators[method_name] = klass
+      install_symbol_method(method_name)
+    end
+
+    # Defines `method_name` on {SymbolMethods} unless `Symbol` already has
+    # a method of that name from somewhere other than Parse.
+    # @!visibility private
+    def self.install_symbol_method(method_name)
+      existing = ::Symbol.method_defined?(method_name) &&
+                 ::Symbol.instance_method(method_name).owner
+      if existing && existing != SymbolMethods
+        symbol_conflicts << method_name unless symbol_conflicts.include?(method_name)
+        return false
+      end
+      if SymbolMethods.method_defined?(method_name, false)
+        SymbolMethods.send(:remove_method, method_name)
+      end
+      op = method_name
+      SymbolMethods.send :define_method, method_name do |value = nil|
         operation = Operation.new self, op
         value.nil? ? operation : operation.constraint(value)
       end
+      true
     end
   end
 end
+
+# Included (not prepended) so methods defined on Symbol itself, by Ruby or
+# by another library, keep precedence over the Parse query DSL.
+Symbol.include(Parse::Operation::SymbolMethods)

data/lib/parse/query/ordering.rb

@@ -56,11 +56,39 @@ module Parse
   end # Order
 end
 
-# Extension to add all the operator instance methods to the Symbol classe
-class Symbol
-  Parse::Order::ORDERING.keys.each do |sym|
-    define_method(sym) do
-      Parse::Order.new self, sym
+module Parse
+  class Order
+    # Carries the `:field.asc` / `:field.desc` sort helpers. Included into
+    # `Symbol` rather than defined on it, and skipped for any name another
+    # library already defines on `Symbol` (Mongoid, Sequel core extensions),
+    # so Parse never replaces another library's `Symbol#asc` or `#desc`.
+    # Use `Parse::Order.new(:field, :desc)` when such a library is loaded.
+    module SymbolMethods; end
+
+    # Converts another library's sort key (Mongoid's `:field.desc` when
+    # Mongoid owns `Symbol#desc`) into a {Parse::Order}.
+    # @param value [Object]
+    # @return [Parse::Order, nil] nil when `value` is not a known foreign sort key.
+    def self.from_foreign(value)
+      return value if value.is_a?(Parse::Order)
+      if defined?(::Mongoid::Criteria::Queryable::Key) &&
+         value.is_a?(::Mongoid::Criteria::Queryable::Key)
+        case value.operator
+        when 1, "1" then return new(value.name, :asc)
+        when -1, "-1" then return new(value.name, :desc)
+        end
+      end
+      nil
     end
-  end # each
+
+    ORDERING.keys.each do |sym|
+      existing = ::Symbol.method_defined?(sym) && ::Symbol.instance_method(sym).owner
+      next if existing && existing != SymbolMethods
+      SymbolMethods.send(:define_method, sym) do
+        Parse::Order.new self, sym
+      end
+    end
+  end
 end
+
+Symbol.include(Parse::Order::SymbolMethods)