parse-stack 1.7.3 → 1.9.1

data/lib/parse/query.rb

@@ -5,11 +5,11 @@ require_relative "client"
 require_relative "query/operation"
 require_relative "query/constraints"
 require_relative "query/ordering"
-require 'active_model'
-require 'active_model_serializers'
-require 'active_support'
-require 'active_support/inflector'
-require 'active_support/core_ext'
+require "active_model"
+require "active_model_serializers"
+require "active_support"
+require "active_support/inflector"
+require "active_support/core_ext"
 
 module Parse
   # The {Parse::Query} class provides the lower-level querying interface for
@@ -62,7 +62,7 @@ module Parse
   # You can build your own custom query constraints by creating a `Parse::Constraint`
   # subclass. For all these `where` clauses assume `q` is a `Parse::Query` object.
   class Query
-    extend  ::ActiveModel::Callbacks
+    extend ::ActiveModel::Callbacks
     include Parse::Client::Connectable
     include Enumerable
     # @!group Callbacks
@@ -196,8 +196,8 @@ module Parse
       # @param table [String] the name of the Parse collection to query. (ex. "_User")
       # @param constraints [Hash] a set of query constraints.
       # @return [Query] a new query for the Parse collection with the passed in constraints.
-      def all(table, constraints = {limit: :max})
-        self.new(table, constraints.reverse_merge({limit: :max}))
+      def all(table, constraints = { limit: :max })
+        self.new(table, constraints.reverse_merge({ limit: :max }))
       end
 
       # This methods takes a set of constraints and merges them to build a final
@@ -205,7 +205,7 @@ module Parse
       # @param where [Array] an array of {Parse::Constraint} objects.
       # @return [Hash] a hash representing the compiled query
       def compile_where(where)
-        constraint_reduce( where )
+        constraint_reduce(where)
       end
 
       # @!visibility private
@@ -214,7 +214,7 @@ module Parse
         clauses.reduce({}) do |clause, subclause|
           #puts "Merging Subclause: #{subclause.as_json}"
 
-          clause.deep_merge!( subclause.as_json || {} )
+          clause.deep_merge!(subclause.as_json || {})
           clause
         end
       end
@@ -228,7 +228,6 @@ module Parse
           query.define_singleton_method(:inspect) { self.results.to_a.inspect }
         end
       end
-
     end
 
     # @!attribute [r] client
@@ -314,7 +313,7 @@ module Parse
         elsif expression == :keys
           keys value
         elsif expression == :key
-          @key = value
+          keys [value]
         elsif expression == :skip
           skip value
         elsif expression == :limit
@@ -334,6 +333,7 @@ module Parse
       end # each
       self #chaining
     end
+
     alias_method :query, :conditions
     alias_method :append, :conditions
 
@@ -418,7 +418,7 @@ module Parse
     # @param amount [Integer] The number of records to skip.
     # @return [self]
     def skip(amount)
-      @skip = [0,amount.to_i].max
+      @skip = [0, amount.to_i].max
       @results = nil
       self #chaining
     end
@@ -434,11 +434,11 @@ module Parse
     #  Song.all :limit => 2025 # large limits supported.
     #  Song.all :limit => :max # as many records as possible.
     # @param count [Integer,Symbol] The number of records to return. You may pass :max
-    #  to get as many as 11_000 records with the aid if skipping.
+    #  to get as many records as possible (Parse-Server dependent).
     # @return [self]
     def limit(count)
       if count.is_a?(Numeric)
-        @limit = [ 0, count.to_i ].max
+        @limit = [0, count.to_i].max
       elsif count == :max
         @limit = :max
       else
@@ -497,10 +497,15 @@ module Parse
     #  # add where :like_count is greater than 20
     #  query.add_constraint(:like_count.gt, 20)
     #
+    #  # same, but ignore field formatting
+    #  query.add_constraint(:like_count.gt, 20, filter: false)
+    #
     # @param operator [Parse::Operator] an operator object containing the operation and operand.
     # @param value [Object] the value for the constraint.
+    # @param opts [Object] A set of options. Passing :filter with false, will skip field formatting.
+    # @see Query#format_field
     # @return [self]
-    def add_constraint(operator, value = nil, **opts)
+    def add_constraint(operator, value = nil, opts = {})
       @where ||= []
       constraint = operator # assume Parse::Constraint
       unless constraint.is_a?(Parse::Constraint)
@@ -579,7 +584,7 @@ module Parse
     # @return [Query] the combined query with an OR clause.
     def or_where(where_clauses = [])
       where_clauses = where_clauses.where if where_clauses.is_a?(Parse::Query)
-      where_clauses = Parse::Query.new(@table, where_clauses ).where if where_clauses.is_a?(Hash)
+      where_clauses = Parse::Query.new(@table, where_clauses).where if where_clauses.is_a?(Hash)
       return self if where_clauses.blank?
       # we can only have one compound query constraint. If we need to add another OR clause
       # let's find the one we have (if any)
@@ -589,7 +594,7 @@ module Parse
       # if we don't have a OR clause to reuse, then create a new one with then
       # current set of constraints
       if compound.blank?
-        compound = Parse::Constraint::CompoundQueryConstraint.new :or, [ Parse::Query.compile_where(remaining_clauses) ]
+        compound = Parse::Constraint::CompoundQueryConstraint.new :or, [Parse::Query.compile_where(remaining_clauses)]
       end
       # then take the where clauses from the second query and append them.
       compound.value.push Parse::Query.compile_where(where_clauses)
@@ -601,10 +606,39 @@ module Parse
     # @see #or_where
     # @return [Query] the combined query with an OR clause.
     def |(other_query)
-        raise ArgumentError, "Parse queries must be of the same class #{@table}." unless @table == other_query.table
-        copy_query = self.clone
-        copy_query.or_where other_query.where
-        copy_query
+      raise ArgumentError, "Parse queries must be of the same class #{@table}." unless @table == other_query.table
+      copy_query = self.clone
+      copy_query.or_where other_query.where
+      copy_query
+    end
+
+    # Queries can be made using distinct, allowing you find unique values for a specified field.
+    # For this to be performant, please remember to index your database.
+    # @example
+    #   # Return a set of unique city names
+    #   # for users who are greater than 21 years old
+    #   Parse::Query.all(distinct: :age)
+    #   query = Parse::Query.new("_User")
+    #   query.where :age.gt => 21
+    #   # triggers query
+    #   query.distinct(:city) #=> ["San Diego", "Los Angeles", "San Juan"]
+    # @note This feature requires use of the Master Key in the API.
+    # @param field [Symbol|String] The name of the field used for filtering.
+    # @version 1.8.0
+    def distinct(field)
+      if field.nil? == false && field.respond_to?(:to_s)
+        # disable counting if it was enabled.
+        old_count_value = @count
+        @count = nil
+        compile_query = compile # temporary store
+        # add distinct field
+        compile_query[:distinct] = Query.format_field(field).to_sym
+        @count = old_count_value
+        # perform aggregation
+        return client.aggregate_objects(@table, compile_query.as_json, _opts).result
+      else
+        raise ArgumentError, "Invalid field name passed to `distinct`."
+      end
     end
 
     # Perform a count query.
@@ -620,7 +654,7 @@ module Parse
     def count
       old_value = @count
       @count = 1
-      res = client.find_objects(@table, compile.as_json, _opts ).count
+      res = client.find_objects(@table, compile.as_json, _opts).count
       @count = old_value
       res
     end
@@ -629,8 +663,8 @@ module Parse
     # @return [Array]
     # @see Array#each
     def each
-       return results.enum_for(:each) unless block_given? # Sparkling magic!
-       results.each(&Proc.new)
+      return results.enum_for(:each) unless block_given? # Sparkling magic!
+      results.each(&Proc.new)
     end
 
     # @yield a block yield for each object in the result
@@ -684,7 +718,7 @@ module Parse
           compiled_query[:limit] = _limit if _limit < batch_size
         end
 
-        response = fetch!( compiled_query )
+        response = fetch!(compiled_query)
         break if response.error? || response.results.empty?
 
         items = response.results
@@ -732,13 +766,13 @@ module Parse
     # @param compiled_query [Hash] the compiled query
     # @return [Parse::Response] a response for a query request.
     def fetch!(compiled_query)
-
-      response = client.find_objects(@table, compiled_query.as_json, _opts )
+      response = client.find_objects(@table, compiled_query.as_json, _opts)
       if response.error?
         puts "[ParseQuery] #{response.error}"
       end
       response
     end
+
     alias_method :execute!, :fetch!
 
     # Executes the query and builds the result set of Parse::Objects that matched.
@@ -767,7 +801,7 @@ module Parse
         if block_given?
           max_results(raw: raw, &Proc.new)
         elsif @limit.is_a?(Numeric)
-          response = fetch!( compile )
+          response = fetch!(compile)
           return [] if response.error?
           items = raw ? response.results : decode(response.results)
           return items.each(&Proc.new) if block_given?
@@ -778,6 +812,7 @@ module Parse
       end
       @results
     end
+
     alias_method :result, :results
 
     # Similar to {#results} but takes an additional set of conditions to apply. This
@@ -787,7 +822,7 @@ module Parse
     # @return [Array<Hash>] if raw is set to true, a set of Parse JSON hashes.
     # @return [Array<Parse::Object>] if raw is set to false, a list of matching Parse::Object subclasses.
     # @see #results
-    def all(expressions = {limit: :max})
+    def all(expressions = { limit: :max })
       conditions(expressions)
       return results(&Proc.new) if block_given?
       results
@@ -825,9 +860,9 @@ module Parse
         q[:limit] = @limit if @limit.is_a?(Numeric) && @limit > 0
         q[:skip] = @skip if @skip > 0
 
-        q[:include] = @includes.join(',') unless @includes.empty?
-        q[:keys] = @keys.join(',')  unless @keys.empty?
-        q[:order] = @order.join(',') unless @order.empty?
+        q[:include] = @includes.join(",") unless @includes.empty?
+        q[:keys] = @keys.join(",") unless @keys.empty?
+        q[:order] = @order.join(",") unless @order.empty?
         unless @where.empty?
           q[:where] = Parse::Query.compile_where(@where)
           q[:where] = q[:where].to_json if encode
@@ -847,15 +882,13 @@ module Parse
 
     # @return [Hash] a hash representing just the `where` clause of this query.
     def compile_where
-      self.class.compile_where( @where || [] )
+      self.class.compile_where(@where || [])
     end
 
     # Retruns a formatted JSON string representing the query, useful for debugging.
     # @return [String]
     def pretty
-      JSON.pretty_generate( as_json )
+      JSON.pretty_generate(as_json)
     end
-
   end # Query
-
 end # Parse

data/lib/parse/query/constraint.rb

@@ -1,9 +1,9 @@
 # encoding: UTF-8
 # frozen_string_literal: true
 
-require_relative 'operation'
-require 'time'
-require 'date'
+require_relative "operation"
+require "time"
+require "date"
 
 module Parse
   # Constraints are the heart of the Parse::Query system.
@@ -39,12 +39,11 @@ module Parse
       # it most likely is just the field name, so let's assume they want
       # the default equality operation.
       if operation.is_a?(Operation) == false && operation.respond_to?(:to_sym)
-          operation = Operation.new(operation.to_sym, self.class.operand)
+        operation = Operation.new(operation.to_sym, self.class.operand)
       end
       @operation = operation
       @value = value
       yield(self) if block_given?
-
     end
 
     class << self
@@ -122,7 +121,6 @@ module Parse
         end
         d
       end
-
     end
 
     # @return [Integer] the precedence of this constraint

data/lib/parse/query/constraints.rb

@@ -1,7 +1,7 @@
 # encoding: UTF-8
 # frozen_string_literal: true
 
-require_relative 'constraint'
+require_relative "constraint"
 
 # Each constraint type is a subclass of Parse::Constraint
 # We register each keyword (which is the Parse query operator)
@@ -60,7 +60,7 @@ module Parse
         value = formatted_value
         # if it is already a pointer value, just return the constraint. Allows for
         # supporting strings, symbols and pointers.
-        return { @operation.operand  => value } if value.is_a?(Parse::Pointer)
+        return { @operation.operand => value } if value.is_a?(Parse::Pointer)
 
         begin
           klass = className.constantize
@@ -79,9 +79,8 @@ module Parse
           raise ArgumentError, "#{self.class}: value must be of string type representing a Parse object id."
         end
         value.strip!
-        return { @operation.operand  => klass.pointer(value) }
+        return { @operation.operand => klass.pointer(value) }
       end
-
     end
 
     # Equivalent to the `$or` Parse query operation. This is useful if you want to
@@ -101,7 +100,6 @@ module Parse
         or_clauses = formatted_value
         return { :$or => Array.wrap(or_clauses) }
       end
-
     end
 
     # Equivalent to the `$lte` Parse query operation. The alias `on_or_before` is provided for readability.
@@ -154,6 +152,7 @@ module Parse
       register :less_than
       register :before
     end
+
     # Equivalent to the `$gt` Parse query operation. The alias `after` is provided for readability.
     #  q.where :field.gt => value
     #  q.where :field.after => date
@@ -252,13 +251,12 @@ module Parse
         end
 
         if value == true
-          return { @operation.operand => { key => false} }
+          return { @operation.operand => { key => false } }
         else
           #current bug in parse where if you want exists => true with geo queries
           # we should map it to a "not equal to null" constraint
           return { @operation.operand => { Parse::Constraint::NotEqualConstraint.key => nil } }
         end
-
       end
     end
 
@@ -319,7 +317,6 @@ module Parse
         val = [val].compact unless val.is_a?(Array)
         { @operation.operand => { key => val } }
       end
-
     end
 
     # Equivalent to the `$nin` Parse query operation. Checks whether the value in
@@ -357,7 +354,6 @@ module Parse
         val = [val].compact unless val.is_a?(Array)
         { @operation.operand => { key => val } }
       end
-
     end
 
     # Equivalent to the $all Parse query operation. Checks whether the value in
@@ -585,7 +581,6 @@ module Parse
       contraint_keyword :$notInQuery
       register :excludes
       register :not_in_query
-
     end
 
     # Equivalent to the `$nearSphere` Parse query operation. This is only applicable
@@ -631,7 +626,6 @@ module Parse
         end
         { @operation.operand => { key => point } }
       end
-
     end
 
     # Equivalent to the `$within` Parse query operation and `$box` geopoint
@@ -661,10 +655,10 @@ module Parse
       def build
         geopoint_values = formatted_value
         unless geopoint_values.is_a?(Array) && geopoint_values.count == 2 &&
-          geopoint_values.first.is_a?(Parse::GeoPoint) && geopoint_values.last.is_a?(Parse::GeoPoint)
-          raise(ArgumentError, '[Parse::Query] Invalid query value parameter passed to `within_box` constraint. ' +
-                  'Values in array must be `Parse::GeoPoint` objects and ' +
-                  'it should be in an array format: [southwestPoint, northeastPoint]' )
+               geopoint_values.first.is_a?(Parse::GeoPoint) && geopoint_values.last.is_a?(Parse::GeoPoint)
+          raise(ArgumentError, "[Parse::Query] Invalid query value parameter passed to `within_box` constraint. " +
+                               "Values in array must be `Parse::GeoPoint` objects and " +
+                               "it should be in an array format: [southwestPoint, northeastPoint]")
         end
         { @operation.operand => { :$within => { :$box => geopoint_values } } }
       end
@@ -703,17 +697,65 @@ module Parse
       def build
         geopoint_values = formatted_value
         unless geopoint_values.is_a?(Array) &&
-               geopoint_values.all? {|point| point.is_a?(Parse::GeoPoint) } &&
+               geopoint_values.all? { |point| point.is_a?(Parse::GeoPoint) } &&
                geopoint_values.count > 2
-          raise ArgumentError, '[Parse::Query] Invalid query value parameter passed to'\
-                      ' `within_polygon` constraint: Value must be an array with 3'\
-                      ' or more `Parse::GeoPoint` objects'
+          raise ArgumentError, "[Parse::Query] Invalid query value parameter passed to" \
+                " `within_polygon` constraint: Value must be an array with 3" \
+                " or more `Parse::GeoPoint` objects"
         end
 
         { @operation.operand => { :$geoWithin => { :$polygon => geopoint_values } } }
       end
     end
 
-  end
+    # Equivalent to the full text search support with `$text` with a set of search crieteria.
+    class FullTextSearchQueryConstraint < Constraint
+      # @!method text_search
+      # A registered method on a symbol to create the constraint. Maps to Parse
+      # operator "$text" with "$search" subconstraint. Takes a hash of parameters.
+      # @example
+      #  # As many points as you want
+      #  q.where :field.text_search => {parameters}
+      #
+      # Where `parameters` can be one of:
+      #   $term : Specify a field to search (Required)
+      #   $language : Determines the list of stop words and the rules for tokenizer.
+      #   $caseSensitive : Enable or disable case sensitive search.
+      #   $diacriticSensitive : Enable or disable diacritic sensitive search
+      #
+      # @note This method will automatically add `$` to each key of the parameters
+      # hash if it doesn't already have it.
+      # @return [WithinPolygonQueryConstraint]
+      # @version 1.8.0 (requires Server v2.5.0 or later)
+      contraint_keyword :$text
+      register :text_search
 
+      # @return [Hash] the compiled constraint.
+      def build
+        params = formatted_value
+
+        params = { :$term => params.to_s } if params.is_a?(String) || params.is_a?(Symbol)
+
+        unless params.is_a?(Hash)
+          raise ArgumentError, "[Parse::Query] Invalid query value parameter passed to" \
+                " `text_search` constraint: Value must be a string or a hash of parameters."
+        end
+
+        params = params.inject({}) do |h, (k, v)|
+          u = k.to_s
+          u = u.columnize.prepend("$") unless u.start_with?("$")
+          h[u] = v
+          h
+        end
+
+        unless params["$term"].present?
+          raise ArgumentError, "[Parse::Query] Invalid query value parameter passed to" \
+                " `text_search` constraint: Missing required `$term` subkey.\n" \
+                "\tExample: #{@operation.operand}.text_search => { term: 'text to search' }"
+        end
+
+        { @operation.operand => { :$text => { :$search => params } } }
+      end
+    end
+  end
 end