parse-stack 1.8.0 → 1.8.1

data/lib/parse/model/push.rb

@@ -1,9 +1,10 @@
 # encoding: UTF-8
 # frozen_string_literal: true
 
-require_relative '../query.rb'
-require_relative '../client.rb'
-require 'active_model_serializers'
+require_relative "../query.rb"
+require_relative "../client.rb"
+require "active_model_serializers"
+
 module Parse
   # This class represents the API to send push notification to devices that are
   # available in the Installation table. Push notifications are implemented
@@ -68,7 +69,7 @@ module Parse
     # @!attribute [rw] channels
     #   @return [Array] an array of strings for subscribed channels.
     attr_accessor :query, :alert, :badge, :sound, :title, :data,
-    :expiration_time, :expiration_interval, :push_time, :channels
+                  :expiration_time, :expiration_interval, :push_time, :channels
 
     alias_method :message, :alert
     alias_method :message=, :alert=
@@ -134,14 +135,13 @@ module Parse
       msg = {
         data: {
           alert: alert,
-          badge: badge || "Increment"
-        }
+          badge: badge || "Increment",
+        },
       }
       msg[:data][:sound] = sound if sound.present?
       msg[:data][:title] = title if title.present?
       msg[:data].merge! @data if @data.is_a?(Hash)
 
-
       if @expiration_time.present?
         msg[:expiration_time] = @expiration_time.respond_to?(:iso8601) ? @expiration_time.iso8601(3) : @expiration_time
       end
@@ -170,9 +170,7 @@ module Parse
     def send(message = nil)
       @alert = message if message.is_a?(String)
       @data = message if message.is_a?(Hash)
-      client.push( payload.as_json )
+      client.push(payload.as_json)
     end
-
   end
-
 end

data/lib/parse/model/shortnames.rb

@@ -1,5 +1,4 @@
-
-require_relative 'object'
+require_relative "object"
 
 # Simple include to use short verion of core class names
 ::Installation = Parse::Installation unless defined?(::Installation)

data/lib/parse/model/time_zone.rb

@@ -1,8 +1,8 @@
 # encoding: UTF-8
 # frozen_string_literal: true
 
-require 'active_support'
-require 'active_support/values/time_zone'
+require "active_support"
+require "active_support/values/time_zone"
 require_relative "model"
 
 module Parse
@@ -118,7 +118,7 @@ module Parse
         @name = timezone
         @zone = nil
       else
-        raise ArgumentError, 'Invalid value passed to Parse::TimeZone#zone.'
+        raise ArgumentError, "Invalid value passed to Parse::TimeZone#zone."
       end
     end
 
@@ -137,7 +137,5 @@ module Parse
     def valid?
       ActiveSupport::TimeZone[to_s].present?
     end
-
   end
-
 end

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
@@ -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
@@ -438,7 +438,7 @@ module Parse
     # @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
@@ -584,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)
@@ -594,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)
@@ -606,10 +606,10 @@ 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.
@@ -635,7 +635,7 @@ module Parse
         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
+        return client.aggregate_objects(@table, compile_query.as_json, _opts).result
       else
         raise ArgumentError, "Invalid field name passed to `distinct`."
       end
@@ -654,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
@@ -663,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
@@ -718,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
@@ -766,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.
@@ -801,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?
@@ -812,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
@@ -821,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
@@ -859,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
@@ -881,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,18 +697,18 @@ 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
 
-
+    # 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
@@ -743,27 +737,25 @@ module Parse
         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.'
+          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)|
+        params = params.inject({}) do |h, (k, v)|
           u = k.to_s
-          u = u.columnize.prepend('$') unless u.start_with?('$')
+          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' }"
+          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