parse-stack 1.5.3 → 1.6.0

data/lib/parse/model/pointer.rb

@@ -65,7 +65,7 @@ module Parse
     #
     # @see Parse::Object
     class Pointer < Model
-      # Attributes of a Pointer.
+      # The default attributes in a Parse Pointer hash.
       ATTRIBUTES = { __type: :string, className: :string, objectId: :string}.freeze
       # @return [String] the name of the Parse class for this pointer.
       attr_accessor :parse_class
@@ -155,6 +155,27 @@ module Parse
       def present?
         parse_class.present? && @id.present?
       end
+
+      # Access the pointer properties through hash accessor. This is done for
+      # compatibility with the hash access of a Parse::Object. This method
+      # returns nil if the key is not one of: :id, :objectId, or :className.
+      # @param key [String] the name of the property.
+      # @return [Object] the value for this key.
+      def [](key)
+        return nil unless [:id,:objectId,:className].include?(key.to_sym)
+        send(key)
+      end
+
+      # Set the pointer properties through hash accessor. This is done for
+      # compatibility with the hash access of a Parse::Object. This method
+      # does nothing if the key is not one of: :id, :objectId, or :className.
+      # @param key (see #[])
+      # @return [Object]
+      def []=(key,value)
+        return unless [:id,:objectId,:className].include?(key.to_sym)
+        send("#{key}=",value)
+      end
+
     end
 
 end

data/lib/parse/model/push.rb

@@ -89,12 +89,16 @@ module Parse
       @query ||= Parse::Query.new(Parse::Model::CLASS_INSTALLATION)
     end
 
-    # @!attribute [rw] where
-    #   @return [Hash] a hash of 'where' query constraints
+    # Set a hash of conditions for this push query.
+    # @return [Parse::Query]
     def where=(where_clausees)
       query.where where_clauses
     end
 
+    # Apply a set of constraints.
+    # @param constraints [Hash] the set of {Parse::Query} cosntraints
+    # @return [Hash] if no constraints were passed, returns a compiled query.
+    # @return [Parse::Query] if constraints were passed, returns the chainable query.
     def where(constraints = nil)
       return query.compile_where unless constraints.is_a?(Hash)
       query.where constraints

data/lib/parse/query.rb

@@ -150,13 +150,24 @@ module Parse
     # if you do not want any field formatting to be performed.
 
     @field_formatter = :columnize
+    @allow_scope_introspection = false
     class << self
+
+      # @!attribute allow_scope_introspection
+      # The attribute will prevent automatically fetching results of a scope when
+      # using the console. This is useful when you want to see the queries of scopes
+      # instead of automatically returning the results.
+      # @return [Boolean] true to have scopes return query objects instead of results when
+      #  running in the console.
+
+      # @!attribute field_formatter
       # The method to use when converting field names to Parse column names. Default is {String#columnize}.
       # By convention Parse uses lowercase-first camelcase syntax for field/column names, but ruby
       # uses snakecase. To support this methodology we process all field constraints through the method
       # defined by the field formatter. You may set this to nil to turn off this functionality.
       # @return [Symbol] The filter method to process column and field names. Default {String#columnize}.
-      attr_accessor :field_formatter
+
+      attr_accessor :field_formatter, :allow_scope_introspection
 
       # @param str [String] the string to format
       # @return [String] formatted string using {Parse::Query.field_formatter}.
@@ -196,6 +207,16 @@ module Parse
         end
       end
 
+      # Applies special singleton methods to a query instance in order to
+      # automatically fetch results when using any ruby console.
+      # @!visibility private
+      def apply_auto_introspection!(query)
+        unless @allow_scope_introspection
+          query.define_singleton_method(:to_s) { self.results.to_s }
+          query.define_singleton_method(:inspect) { self.results.to_a.inspect }
+        end
+      end
+
     end
 
     # @!attribute [r] client
@@ -269,7 +290,10 @@ module Parse
     end # initialize
 
     # Add a set of query expressions and constraints.
-    # @param expressions
+    # @example
+    #  query.conditions({:field.gt => value})
+    # @param expressions [Hash] containing key value pairs of Parse::Operations
+    #   and their value.
     # @return [self]
     def conditions(expressions = {})
       expressions.each do |expression, value|
@@ -390,7 +414,7 @@ module Parse
     #  to get as many as 11_000 records with the aid if skipping.
     # @return [self]
     def limit(count)
-      if count == :max || count == :all
+      if count == :max
         @limit = 11_000
       elsif count.is_a?(Numeric)
         @limit = [ 0, count.to_i, 11_000].sort[1]
@@ -475,10 +499,19 @@ module Parse
       self #chaining
     end
 
-    # @return [Array<Parse::Constraint>] an array of constraints
+    # @param raw [Boolean] whether to return the hash form of the constraints.
+    # @return [Array<Parse::Constraint>] if raw is false, an array of constraints
     #  composing the :where clause for this query.
-    def constraints
-      @where
+    # @return [Hash] if raw i strue, an hash representing the constraints.
+    def constraints(raw = false)
+      raw ? where_constraints : @where
+    end
+
+    # Formats the current set of Parse::Constraint instances in the where clause
+    # as an expression hash.
+    # @return [Hash] the set of constraints
+    def where_constraints
+      @where.reduce({}) { |memo, constraint| memo[constraint.operation] = constraint.value; memo }
     end
 
     # Add additional query constraints to the `where` clause. The `where` clause
@@ -527,17 +560,17 @@ module Parse
       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)
-      compound = @where.find { |f| f.is_a?(Parse::CompoundQueryConstraint) }
+      compound = @where.find { |f| f.is_a?(Parse::Constraint::CompoundQueryConstraint) }
       # create a set of clauses that are not an OR clause.
-      remaining_clauses = @where.select { |f| f.is_a?(Parse::CompoundQueryConstraint) == false }
+      remaining_clauses = @where.select { |f| f.is_a?(Parse::Constraint::CompoundQueryConstraint) == false }
       # 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::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)
-      #compound = Parse::CompoundQueryConstraint.new :or, [remaining_clauses, or_where_query.where]
+      #compound = Parse::Constraint::CompoundQueryConstraint.new :or, [remaining_clauses, or_where_query.where]
       @where = [compound]
       self #chaining
     end
@@ -705,6 +738,19 @@ module Parse
     end
     alias_method :result, :results
 
+    # Similar to {#results} but takes an additional set of conditions to apply. This
+    # method helps support the use of class and instance level scopes.
+    # @param expressions (see #conditions)
+    # @yield (see #results)
+    # @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})
+      conditions(expressions)
+      return results(&Proc.new) if block_given?
+      results
+    end
+
     # Builds objects based on the set of Parse JSON hashes in an array.
     # @param list [Array<Hash>] a list of Parse JSON hashes
     # @return [Array<Parse::Object>] an array of Parse::Object subclasses.
@@ -734,7 +780,7 @@ module Parse
     def compile(encode: true, includeClassName: false)
       run_callbacks :prepare do
         q = {} #query
-        q[:limit] = 11_000 if @limit == :max || @limit == :all
+        q[:limit] = 11_000 if @limit == :max
         q[:limit] = @limit if @limit.is_a?(Numeric) && @limit > 0
         q[:skip] = @skip if @skip > 0
 

data/lib/parse/query/constraint.rb

@@ -12,6 +12,7 @@ module Parse
   # be combined by merging different constraints (since they are multiple hashes)
   # and some constraints may have higher precedence than others (ex. equality is higher
   # precedence than an "in" query).
+  #
   # All constraints should inherit from Parse::Constraint and should
   # register their specific Operation method (ex. :eq or :lte)
   # For more information about the query design pattern from DataMapper
@@ -102,8 +103,8 @@ module Parse
       # @return [Object] a formatted value based on the data type.
       def formatted_value(value)
         d = value
-        d = { __type: "Date", iso: d.utc.iso8601(3) } if d.respond_to?(:utc)
-        d = { __type: "Date", iso: d.iso8601(3) } if d.respond_to?(:iso8601)
+        d = { __type: Parse::Model::TYPE_DATE, iso: d.utc.iso8601(3) } if d.respond_to?(:utc)
+        d = { __type: Parse::Model::TYPE_DATE, iso: d.iso8601(3) } if d.respond_to?(:iso8601)
         d = d.pointer if d.respond_to?(:pointer) #simplified query object
         d = d.to_s if d.is_a?(Regexp)
         #d = d.pointer if d.is_a?(Parse::Object) #simplified query object
@@ -162,6 +163,8 @@ module Parse
     # Builds the JSON hash representation of this constraint for a Parse query.
     # This method should be overriden by subclasses. The default implementation
     # implements buildling the equality constraint.
+    # @raise ArgumentError if the constraint could be be build due to a bad parameter.
+    #  This will be different depending on the constraint subclass.
     # @return [Hash]
     def build
       return { @operation.operand => formatted_value } if @operation.operator == :eq || key.nil?

data/lib/parse/query/constraints.rb

@@ -12,656 +12,655 @@ require_relative 'constraint'
 # that inspired this, see http://datamapper.org/docs/find.html
 
 module Parse
-  # Error for when there is a problem with the input passed to a constraint.
-  class ConstraintError < StandardError; 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"
-  #  # "field":{"__type":"Pointer","className":"Field","objectId":"someObjectId"}}
-  #
-  #  class Artist < Parse::Object
-  #  end
-  #
-  #  class Song < Parse::Object
-  #    belongs_to :artist
-  #  end
-  #
-  #  artist = Artist.first # get any artist
-  #  artist_id = artist.id # ex. artist.id
-  #
-  #  # find all songs for this artist object
-  #  Song.all :artist => artist
-  # In some cases, you do not have the Parse object, but you have its `objectId`.
-  # 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
-  #
-  #  # other approaches, same result
-  #  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.
-    # @example
+  class Constraint
+    # 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"
-    # @return [ObjectIdConstraint]
-    register :id
-
-    # @return [Hash] the compiled constraint.
-    def build
-      className = operand.to_parse_class
-      value = formatted_value
-      begin
-        klass = className.constantize
-      rescue NameError => e
-        klass = Parse::Model.find_class className
-      end
+    #  # "field":{"__type":"Pointer","className":"Field","objectId":"someObjectId"}}
+    #
+    #  class Artist < Parse::Object
+    #  end
+    #
+    #  class Song < Parse::Object
+    #    belongs_to :artist
+    #  end
+    #
+    #  artist = Artist.first # get any artist
+    #  artist_id = artist.id # ex. artist.id
+    #
+    #  # find all songs for this artist object
+    #  Song.all :artist => artist
+    # In some cases, you do not have the Parse object, but you have its `objectId`.
+    # 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
+    #
+    #  # other approaches, same result
+    #  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.
+      # @example
+      #  q.where :field.id => "someObjectId"
+      # @return [ObjectIdConstraint]
+      register :id
+
+      # @return [Hash] the compiled constraint.
+      def build
+        className = operand.to_parse_class
+        value = formatted_value
+        begin
+          klass = className.constantize
+        rescue NameError => e
+          klass = Parse::Model.find_class className
+        end
 
-      unless klass.present? && klass.is_a?(Parse::Object) == false
-        raise ConstraintError, "#{self.class}: No Parse class defined for #{operand} as '#{className}'"
-      end
+        unless klass.present? && klass.is_a?(Parse::Object) == false
+          raise ArgumentError, "#{self.class}: No Parse class defined for #{operand} as '#{className}'"
+        end
 
-      # allow symbols
-      value = value.to_s if value.is_a?(Symbol)
+        # allow symbols
+        value = value.to_s if value.is_a?(Symbol)
 
-      unless value.is_a?(String) && value.strip.present?
-        raise ConstraintError, "#{self.class}: value must be of string type representing a Parse object id."
+        unless value.is_a?(String) && value.strip.present?
+          raise ArgumentError, "#{self.class}: value must be of string type representing a Parse object id."
+        end
+        value.strip!
+        return { @operation.operand  => klass.pointer(value) }
       end
-      value.strip!
-      return { @operation.operand  => klass.pointer(value) }
+
     end
 
-  end
+    # Equivalent to the `$or` Parse query operation. This is useful if you want to
+    # find objects that match several queries. We overload the `|` operator in
+    # order to have a clean syntax for joining these `or` operations.
+    #  or_query = query1 | query2 | query3
+    #  query = Player.where(:wins.gt => 150) | Player.where(:wins.lt => 5)
+    #
+    #  query.or_where :field => value
+    #
+    class CompoundQueryConstraint < Constraint
+      contraint_keyword :$or
+      register :or
+
+      # @return [Hash] the compiled constraint.
+      def build
+        or_clauses = formatted_value
+        return { :$or => Array.wrap(or_clauses) }
+      end
 
-  # Equivalent to the `$or` Parse query operation. This is useful if you want to
-  # find objects that match several queries. We overload the `|` operator in
-  # order to have a clean syntax for joining these `or` operations.
-  #  or_query = query1 | query2 | query3
-  #  query = Player.where(:wins.gt => 150) | Player.where(:wins.lt => 5)
-  #
-  #  query.or_where :field => value
-  #
-  class CompoundQueryConstraint < Constraint
-    contraint_keyword :$or
-    register :or
-
-    # @return [Hash] the compiled constraint.
-    def build
-      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.
-  #  q.where :field.lte => value
-  #  q.where :field.on_or_before => date
-  #
-  #  q.where :created_at.on_or_before => DateTime.now
-  # @see LessThanConstraint
-  class LessThanOrEqualConstraint < Constraint
-    # @!method lte
-    # A registered method on a symbol to create the constraint. Maps to Parse operator "$lte".
-    # @example
+    # Equivalent to the `$lte` Parse query operation. The alias `on_or_before` is provided for readability.
     #  q.where :field.lte => value
-    # @return [LessThanOrEqualConstraint]
-
-    # @!method less_than_or_equal
-    # Alias for {lte}
-    # @return [LessThanOrEqualConstraint]
-
-    # @!method on_or_before
-    # Alias for {lte} that provides better readability when constraining dates.
-    # @return [LessThanOrEqualConstraint]
-    contraint_keyword :$lte
-    register :lte
-    register :less_than_or_equal
-    register :on_or_before
-  end
+    #  q.where :field.on_or_before => date
+    #
+    #  q.where :created_at.on_or_before => DateTime.now
+    # @see LessThanConstraint
+    class LessThanOrEqualConstraint < Constraint
+      # @!method lte
+      # A registered method on a symbol to create the constraint. Maps to Parse operator "$lte".
+      # @example
+      #  q.where :field.lte => value
+      # @return [LessThanOrEqualConstraint]
+
+      # @!method less_than_or_equal
+      # Alias for {lte}
+      # @return [LessThanOrEqualConstraint]
+
+      # @!method on_or_before
+      # Alias for {lte} that provides better readability when constraining dates.
+      # @return [LessThanOrEqualConstraint]
+      contraint_keyword :$lte
+      register :lte
+      register :less_than_or_equal
+      register :on_or_before
+    end
 
-  # Equivalent to the `$lt` Parse query operation. The alias `before` is provided for readability.
-  #  q.where :field.lt => value
-  #  q.where :field.before => date
-  #
-  #  q.where :created_at.before => DateTime.now
-  class LessThanConstraint < Constraint
-    # @!method lt
-    # A registered method on a symbol to create the constraint. Maps to Parse operator "$lt".
-    # @example
+    # Equivalent to the `$lt` Parse query operation. The alias `before` is provided for readability.
     #  q.where :field.lt => value
-    # @return [LessThanConstraint]
-
-    # @!method less_than
-    # # Alias for {lt}.
-    # @return [LessThanConstraint]
-
-    # @!method before
-    # Alias for {lt} that provides better readability when constraining dates.
-    # @return [LessThanConstraint]
-    contraint_keyword :$lt
-    register :lt
-    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
-  #
-  #  q.where :created_at.after => DateTime.now
-  # @see GreaterThanOrEqualConstraint
-  class GreaterThanConstraint < Constraint
-    # @!method gt
-    # A registered method on a symbol to create the constraint. Maps to Parse operator "$gt".
-    # @example
+    #  q.where :field.before => date
+    #
+    #  q.where :created_at.before => DateTime.now
+    class LessThanConstraint < Constraint
+      # @!method lt
+      # A registered method on a symbol to create the constraint. Maps to Parse operator "$lt".
+      # @example
+      #  q.where :field.lt => value
+      # @return [LessThanConstraint]
+
+      # @!method less_than
+      # # Alias for {lt}.
+      # @return [LessThanConstraint]
+
+      # @!method before
+      # Alias for {lt} that provides better readability when constraining dates.
+      # @return [LessThanConstraint]
+      contraint_keyword :$lt
+      register :lt
+      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
-    # @return [GreaterThanConstraint]
-
-    # @!method greater_than
-    # # Alias for {gt}.
-    # @return [GreaterThanConstraint]
-
-    # @!method after
-    # Alias for {gt} that provides better readability when constraining dates.
-    # @return [GreaterThanConstraint]
-    contraint_keyword :$gt
-    register :gt
-    register :greater_than
-    register :after
-  end
+    #  q.where :field.after => date
+    #
+    #  q.where :created_at.after => DateTime.now
+    # @see GreaterThanOrEqualConstraint
+    class GreaterThanConstraint < Constraint
+      # @!method gt
+      # A registered method on a symbol to create the constraint. Maps to Parse operator "$gt".
+      # @example
+      #  q.where :field.gt => value
+      # @return [GreaterThanConstraint]
+
+      # @!method greater_than
+      # # Alias for {gt}.
+      # @return [GreaterThanConstraint]
+
+      # @!method after
+      # Alias for {gt} that provides better readability when constraining dates.
+      # @return [GreaterThanConstraint]
+      contraint_keyword :$gt
+      register :gt
+      register :greater_than
+      register :after
+    end
 
-  # Equivalent to the `$gte` Parse query operation. The alias `on_or_after` is provided for readability.
-  #  q.where :field.gte => value
-  #  q.where :field.on_or_after => date
-  #
-  #  q.where :created_at.on_or_after => DateTime.now
-  # @see GreaterThanConstraint
-  class GreaterThanOrEqualConstraint < Constraint
-    # @!method gte
-    # A registered method on a symbol to create the constraint. Maps to Parse operator "$gte".
-    # @example
+    # Equivalent to the `$gte` Parse query operation. The alias `on_or_after` is provided for readability.
     #  q.where :field.gte => value
-    # @return [GreaterThanOrEqualConstraint]
-
-    # @!method greater_than_or_equal
-    # # Alias for {gte}.
-    # @return [GreaterThanOrEqualConstraint]
-
-    # @!method on_or_after
-    # Alias for {gte} that provides better readability when constraining dates.
-    # @return [GreaterThanOrEqualConstraint]
-    contraint_keyword :$gte
-    register :gte
-    register :greater_than_or_equal
-    register :on_or_after
-  end
+    #  q.where :field.on_or_after => date
+    #
+    #  q.where :created_at.on_or_after => DateTime.now
+    # @see GreaterThanConstraint
+    class GreaterThanOrEqualConstraint < Constraint
+      # @!method gte
+      # A registered method on a symbol to create the constraint. Maps to Parse operator "$gte".
+      # @example
+      #  q.where :field.gte => value
+      # @return [GreaterThanOrEqualConstraint]
+
+      # @!method greater_than_or_equal
+      # # Alias for {gte}.
+      # @return [GreaterThanOrEqualConstraint]
+
+      # @!method on_or_after
+      # Alias for {gte} that provides better readability when constraining dates.
+      # @return [GreaterThanOrEqualConstraint]
+      contraint_keyword :$gte
+      register :gte
+      register :greater_than_or_equal
+      register :on_or_after
+    end
 
-  # Equivalent to the `$ne` Parse query operation. Where a particular field is not equal to value.
-  #  q.where :field.not => value
-  class NotEqualConstraint < Constraint
-    # @!method not
-    # A registered method on a symbol to create the constraint. Maps to Parse operator "$ne".
-    # @example
+    # Equivalent to the `$ne` Parse query operation. Where a particular field is not equal to value.
     #  q.where :field.not => value
-    # @return [NotEqualConstraint]
-
-    # @!method ne
-    # # Alias for {not}.
-    # @return [NotEqualConstraint]
-    contraint_keyword :$ne
-    register :not
-    register :ne
-  end
+    class NotEqualConstraint < Constraint
+      # @!method not
+      # A registered method on a symbol to create the constraint. Maps to Parse operator "$ne".
+      # @example
+      #  q.where :field.not => value
+      # @return [NotEqualConstraint]
+
+      # @!method ne
+      # # Alias for {not}.
+      # @return [NotEqualConstraint]
+      contraint_keyword :$ne
+      register :not
+      register :ne
+    end
 
-  # Provides a mechanism using the equality operator to check for `(undefined)` values.
-  # Nullabiliity constraint maps the `$exists` Parse clause to enable checking for
-  # existance in a column when performing geoqueries due to a Parse limitation.
-  #  q.where :field.null => false
-  # @note Parse currently has a bug that if you select items near a location
-  #  and want to make sure a different column has a value, you need to
-  #  search where the column does not contanin a null/undefined value.
-  #  Therefore we override the build method to change the operation to a
-  #  {NotEqualConstraint}.
-  # @see ExistsConstraint
-  class NullabilityConstraint < Constraint
-    # @!method null
-    # A registered method on a symbol to create the constraint.
-    # @example
-    #  q.where :field.null => true
-    # @return [NullabilityConstraint]
-    contraint_keyword :$exists
-    register :null
-
-    # @return [Hash] the compiled constraint.
-    def build
-      # if nullability is equal true, then $exists should be set to false
-
-      value = formatted_value
-      unless value == true || value == false
-        raise ConstraintError, "#{self.class}: Non-Boolean value passed, it must be either `true` or `false`"
-      end
+    # Provides a mechanism using the equality operator to check for `(undefined)` values.
+    # Nullabiliity constraint maps the `$exists` Parse clause to enable checking for
+    # existance in a column when performing geoqueries due to a Parse limitation.
+    #  q.where :field.null => false
+    # @note Parse currently has a bug that if you select items near a location
+    #  and want to make sure a different column has a value, you need to
+    #  search where the column does not contanin a null/undefined value.
+    #  Therefore we override the build method to change the operation to a
+    #  {NotEqualConstraint}.
+    # @see ExistsConstraint
+    class NullabilityConstraint < Constraint
+      # @!method null
+      # A registered method on a symbol to create the constraint.
+      # @example
+      #  q.where :field.null => true
+      # @return [NullabilityConstraint]
+      contraint_keyword :$exists
+      register :null
+
+      # @return [Hash] the compiled constraint.
+      def build
+        # if nullability is equal true, then $exists should be set to false
+
+        value = formatted_value
+        unless value == true || value == false
+          raise ArgumentError, "#{self.class}: Non-Boolean value passed, it must be either `true` or `false`"
+        end
 
-      if value == true
-        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::NotEqualConstraint.key => nil } }
-      end
+        if value == true
+          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
-  end
 
-  # Equivalent to the `#exists` Parse query operation. Checks whether a value is
-  # set for key. The difference between this operation and the nullability check
-  # is when using compound queries with location.
-  #  q.where :field.exists => true
-  #
-  # @see NullabilityConstraint
-  class ExistsConstraint < Constraint
-    # @!method exists
-    # A registered method on a symbol to create the constraint. Maps to Parse operator "$exists".
-    # @example
+    # Equivalent to the `#exists` Parse query operation. Checks whether a value is
+    # set for key. The difference between this operation and the nullability check
+    # is when using compound queries with location.
     #  q.where :field.exists => true
-    # @return [ExistsConstraint]
-    contraint_keyword :$exists
-    register :exists
-
-    # @return [Hash] the compiled constraint.
-    def build
-      # if nullability is equal true, then $exists should be set to false
-      value = formatted_value
+    #
+    # @see NullabilityConstraint
+    class ExistsConstraint < Constraint
+      # @!method exists
+      # A registered method on a symbol to create the constraint. Maps to Parse operator "$exists".
+      # @example
+      #  q.where :field.exists => true
+      # @return [ExistsConstraint]
+      contraint_keyword :$exists
+      register :exists
+
+      # @return [Hash] the compiled constraint.
+      def build
+        # if nullability is equal true, then $exists should be set to false
+        value = formatted_value
+
+        unless value == true || value == false
+          raise ArgumentError, "#{self.class}: Non-Boolean value passed, it must be either `true` or `false`"
+        end
 
-      unless value == true || value == false
-        raise ConstraintError, "#{self.class}: Non-Boolean value passed, it must be either `true` or `false`"
+        return { @operation.operand => { key => value } }
       end
-
-      return { @operation.operand => { key => value } }
     end
-  end
 
-  # Equivalent to the `$in` Parse query operation. Checks whether the value in the
-  # column field is contained in the set of values in the target array. If the
-  # field is an array data type, it checks whether at least one value in the
-  # field array is contained in the set of values in the target array.
-  #  q.where :field.in => array
-  #  q.where :score.in => [1,3,5,7,9]
-  #
-  # @see ContainsAllConstraint
-  # @see NotContainedInConstraint
-  class ContainedInConstraint < Constraint
-    # @!method in
-    # A registered method on a symbol to create the constraint. Maps to Parse operator "$in".
-    # @example
+    # Equivalent to the `$in` Parse query operation. Checks whether the value in the
+    # column field is contained in the set of values in the target array. If the
+    # field is an array data type, it checks whether at least one value in the
+    # field array is contained in the set of values in the target array.
     #  q.where :field.in => array
-    # @return [ContainedInConstraint]
-
-    # @!method contained_in
-    # Alias for {in}
-    # @return [ContainedInConstraint]
-    contraint_keyword :$in
-    register :in
-    register :contained_in
-
-    # @return [Hash] the compiled constraint.
-    def build
-      val = formatted_value
-      val = [val].compact unless val.is_a?(Array)
-      { @operation.operand => { key => val } }
-    end
+    #  q.where :score.in => [1,3,5,7,9]
+    #
+    # @see ContainsAllConstraint
+    # @see NotContainedInConstraint
+    class ContainedInConstraint < Constraint
+      # @!method in
+      # A registered method on a symbol to create the constraint. Maps to Parse operator "$in".
+      # @example
+      #  q.where :field.in => array
+      # @return [ContainedInConstraint]
+
+      # @!method contained_in
+      # Alias for {in}
+      # @return [ContainedInConstraint]
+      contraint_keyword :$in
+      register :in
+      register :contained_in
+
+      # @return [Hash] the compiled constraint.
+      def build
+        val = formatted_value
+        val = [val].compact unless val.is_a?(Array)
+        { @operation.operand => { key => val } }
+      end
 
-  end
+    end
 
-  # Equivalent to the `$nin` Parse query operation. Checks whether the value in
-  # the column field is *not* contained in the set of values in the target
-  # array. If the field is an array data type, it checks whether at least one
-  # value in the field array is *not* contained in the set of values in the
-  # target array.
-  #
-  #  q.where :field.not_in => array
-  #  q.where :player_name.not_in => ["Jonathan", "Dario", "Shawn"]
-  # @see ContainedInConstraint
-  # @see ContainsAllConstraint
-  class NotContainedInConstraint < Constraint
-    # @!method not_in
-    # A registered method on a symbol to create the constraint. Maps to Parse operator "$nin".
-    # @example
+    # Equivalent to the `$nin` Parse query operation. Checks whether the value in
+    # the column field is *not* contained in the set of values in the target
+    # array. If the field is an array data type, it checks whether at least one
+    # value in the field array is *not* contained in the set of values in the
+    # target array.
+    #
     #  q.where :field.not_in => array
-    # @return [NotContainedInConstraint]
-
-    # @!method nin
-    # Alias for {not_in}
-    # @return [NotContainedInConstraint]
-
-    # @!method not_contained_in
-    # Alias for {not_in}
-    # @return [NotContainedInConstraint]
-    contraint_keyword :$nin
-    register :not_in
-    register :nin
-    register :not_contained_in
-
-    # @return [Hash] the compiled constraint.
-    def build
-      val = formatted_value
-      val = [val].compact unless val.is_a?(Array)
-      { @operation.operand => { key => val } }
-    end
+    #  q.where :player_name.not_in => ["Jonathan", "Dario", "Shawn"]
+    # @see ContainedInConstraint
+    # @see ContainsAllConstraint
+    class NotContainedInConstraint < Constraint
+      # @!method not_in
+      # A registered method on a symbol to create the constraint. Maps to Parse operator "$nin".
+      # @example
+      #  q.where :field.not_in => array
+      # @return [NotContainedInConstraint]
+
+      # @!method nin
+      # Alias for {not_in}
+      # @return [NotContainedInConstraint]
+
+      # @!method not_contained_in
+      # Alias for {not_in}
+      # @return [NotContainedInConstraint]
+      contraint_keyword :$nin
+      register :not_in
+      register :nin
+      register :not_contained_in
+
+      # @return [Hash] the compiled constraint.
+      def build
+        val = formatted_value
+        val = [val].compact unless val.is_a?(Array)
+        { @operation.operand => { key => val } }
+      end
 
-  end
+    end
 
-  # Equivalent to the $all Parse query operation. Checks whether the value in
-  # the column field contains all of the given values provided in the array. Note
-  # that the field column should be of type {Array} in your Parse class.
-  #
-  #  q.where :field.all => array
-  #  q.where :array_key.all => [2,3,4]
-  #
-  # @see ContainedInConstraint
-  # @see NotContainedInConstraint
-  class ContainsAllConstraint < Constraint
-    # @!method all
-    # A registered method on a symbol to create the constraint. Maps to Parse operator "$all".
-    # @example
+    # Equivalent to the $all Parse query operation. Checks whether the value in
+    # the column field contains all of the given values provided in the array. Note
+    # that the field column should be of type {Array} in your Parse class.
+    #
     #  q.where :field.all => array
-    # @return [ContainsAllConstraint]
-
-    # @!method contains_all
-    # Alias for {all}
-    # @return [ContainsAllConstraint]
-    contraint_keyword :$all
-    register :all
-    register :contains_all
-
-    # @return [Hash] the compiled constraint.
-    def build
-      val = formatted_value
-      val = [val].compact unless val.is_a?(Array)
-      { @operation.operand => { key => val } }
+    #  q.where :array_key.all => [2,3,4]
+    #
+    # @see ContainedInConstraint
+    # @see NotContainedInConstraint
+    class ContainsAllConstraint < Constraint
+      # @!method all
+      # A registered method on a symbol to create the constraint. Maps to Parse operator "$all".
+      # @example
+      #  q.where :field.all => array
+      # @return [ContainsAllConstraint]
+
+      # @!method contains_all
+      # Alias for {all}
+      # @return [ContainsAllConstraint]
+      contraint_keyword :$all
+      register :all
+      register :contains_all
+
+      # @return [Hash] the compiled constraint.
+      def build
+        val = formatted_value
+        val = [val].compact unless val.is_a?(Array)
+        { @operation.operand => { key => val } }
+      end
     end
-  end
 
-  # Equivalent to the `$select` Parse query operation. This matches a value for a
-  # key in the result of a different query.
-  #  q.where :field.select => { key: "field", query: query }
-  #
-  #  # example
-  #  value = { key: 'city', query: Artist.where(:fan_count.gt => 50) }
-  #  q.where :hometown.select => value
-  #
-  #  # if the local field is the same name as the foreign table field, you can omit hash
-  #  # assumes key: 'city'
-  #  q.where :city.select => Artist.where(:fan_count.gt => 50)
-  #
-  class SelectionConstraint < Constraint
-    # @!method select
-    # A registered method on a symbol to create the constraint. Maps to Parse operator "$select".
-    # @return [SelectionConstraint]
-    contraint_keyword :$select
-    register :select
-
-    # @return [Hash] the compiled constraint.
-    def build
-
-      # if it's a hash, then it should be {:key=>"objectId", :query=>[]}
-      remote_field_name = @operation.operand
-      query = nil
-      if @value.is_a?(Hash)
-        res = @value.symbolize_keys
-        remote_field_name = res[:key] || remote_field_name
-        query = res[:query]
-        unless query.is_a?(Parse::Query)
-          raise ConstraintError, "Invalid Parse::Query object provided in :query field of value: #{@operation.operand}.#{$dontSelect} => #{@value}"
+    # Equivalent to the `$select` Parse query operation. This matches a value for a
+    # key in the result of a different query.
+    #  q.where :field.select => { key: "field", query: query }
+    #
+    #  # example
+    #  value = { key: 'city', query: Artist.where(:fan_count.gt => 50) }
+    #  q.where :hometown.select => value
+    #
+    #  # if the local field is the same name as the foreign table field, you can omit hash
+    #  # assumes key: 'city'
+    #  q.where :city.select => Artist.where(:fan_count.gt => 50)
+    #
+    class SelectionConstraint < Constraint
+      # @!method select
+      # A registered method on a symbol to create the constraint. Maps to Parse operator "$select".
+      # @return [SelectionConstraint]
+      contraint_keyword :$select
+      register :select
+
+      # @return [Hash] the compiled constraint.
+      def build
+
+        # if it's a hash, then it should be {:key=>"objectId", :query=>[]}
+        remote_field_name = @operation.operand
+        query = nil
+        if @value.is_a?(Hash)
+          res = @value.symbolize_keys
+          remote_field_name = res[:key] || remote_field_name
+          query = res[:query]
+          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)
+        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)
+        else
+          raise ArgumentError, "Invalid `:select` query constraint. It should follow the format: :field.select => { key: 'key', query: '<Parse::Query>' }"
         end
-        query = query.compile(encode: false, includeClassName: true)
-      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)
-      else
-        raise ConstraintError, "Invalid `:select` query constraint. It should follow the format: :field.select => { key: 'key', query: '<Parse::Query>' }"
+        { @operation.operand => { :$select => { key: remote_field_name, query: query } } }
       end
-      { @operation.operand => { :$select => { key: remote_field_name, query: query } } }
     end
-  end
 
-  # Equivalent to the `$dontSelect` Parse query operation. Requires that a field's
-  # value not match a value for a key in the result of a different query.
-  #
-  #  q.where :field.reject => { key: :other_field, query: query }
-  #
-  #  value = { key: 'city', query: Artist.where(:fan_count.gt => 50) }
-  #  q.where :hometown.reject => value
-  #
-  #  # if the local field is the same name as the foreign table field, you can omit hash
-  #  # assumes key: 'city'
-  #  q.where :city.reject => Artist.where(:fan_count.gt => 50)
-  #
-  # @see SelectionConstraint
-  class RejectionConstraint < Constraint
-
-    # @!method dont_select
-    # A registered method on a symbol to create the constraint. Maps to Parse operator "$dontSelect".
-    # @example
+    # Equivalent to the `$dontSelect` Parse query operation. Requires that a field's
+    # value not match a value for a key in the result of a different query.
+    #
     #  q.where :field.reject => { key: :other_field, query: query }
-    # @return [RejectionConstraint]
-
-    # @!method reject
-    # Alias for {dont_select}
-    # @return [RejectionConstraint]
-    contraint_keyword :$dontSelect
-    register :reject
-    register :dont_select
-
-    # @return [Hash] the compiled constraint.
-    def build
-
-      # if it's a hash, then it should be {:key=>"objectId", :query=>[]}
-      remote_field_name = @operation.operand
-      query = nil
-      if @value.is_a?(Hash)
-        res = @value.symbolize_keys
-        remote_field_name = res[:key] || remote_field_name
-        query = res[:query]
-        unless query.is_a?(Parse::Query)
-          raise ConstraintError, "Invalid Parse::Query object provided in :query field of value: #{@operation.operand}.#{$dontSelect} => #{@value}"
+    #
+    #  value = { key: 'city', query: Artist.where(:fan_count.gt => 50) }
+    #  q.where :hometown.reject => value
+    #
+    #  # if the local field is the same name as the foreign table field, you can omit hash
+    #  # assumes key: 'city'
+    #  q.where :city.reject => Artist.where(:fan_count.gt => 50)
+    #
+    # @see SelectionConstraint
+    class RejectionConstraint < Constraint
+
+      # @!method dont_select
+      # A registered method on a symbol to create the constraint. Maps to Parse operator "$dontSelect".
+      # @example
+      #  q.where :field.reject => { key: :other_field, query: query }
+      # @return [RejectionConstraint]
+
+      # @!method reject
+      # Alias for {dont_select}
+      # @return [RejectionConstraint]
+      contraint_keyword :$dontSelect
+      register :reject
+      register :dont_select
+
+      # @return [Hash] the compiled constraint.
+      def build
+
+        # if it's a hash, then it should be {:key=>"objectId", :query=>[]}
+        remote_field_name = @operation.operand
+        query = nil
+        if @value.is_a?(Hash)
+          res = @value.symbolize_keys
+          remote_field_name = res[:key] || remote_field_name
+          query = res[:query]
+          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)
+        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)
+        else
+          raise ArgumentError, "Invalid `:reject` query constraint. It should follow the format: :field.reject => { key: 'key', query: '<Parse::Query>' }"
         end
-        query = query.compile(encode: false, includeClassName: true)
-      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)
-      else
-        raise ConstraintError, "Invalid `:reject` query constraint. It should follow the format: :field.reject => { key: 'key', query: '<Parse::Query>' }"
+        { @operation.operand => { :$dontSelect => { key: remote_field_name, query: query } } }
       end
-      { @operation.operand => { :$dontSelect => { key: remote_field_name, query: query } } }
     end
-  end
 
-  # Equivalent to the `$regex` Parse query operation. Requires that a field value
-  # match a regular expression.
-  #
-  #  q.where :field.like => /ruby_regex/i
-  #  :name.like => /Bob/i
-  #
-  class RegularExpressionConstraint < Constraint
-    #Requires that a key's value match a regular expression
-
-    # @!method like
-    # A registered method on a symbol to create the constraint. Maps to Parse operator "$regex".
-    # @example
+    # Equivalent to the `$regex` Parse query operation. Requires that a field value
+    # match a regular expression.
+    #
     #  q.where :field.like => /ruby_regex/i
-    # @return [RegularExpressionConstraint]
-
-    # @!method regex
-    # Alias for {like}
-    # @return [RegularExpressionConstraint]
-    contraint_keyword :$regex
-    register :like
-    register :regex
-  end
+    #  :name.like => /Bob/i
+    #
+    class RegularExpressionConstraint < Constraint
+      #Requires that a key's value match a regular expression
+
+      # @!method like
+      # A registered method on a symbol to create the constraint. Maps to Parse operator "$regex".
+      # @example
+      #  q.where :field.like => /ruby_regex/i
+      # @return [RegularExpressionConstraint]
+
+      # @!method regex
+      # Alias for {like}
+      # @return [RegularExpressionConstraint]
+      contraint_keyword :$regex
+      register :like
+      register :regex
+    end
 
-  # Equivalent to the `$relatedTo` Parse query operation. If you want to
-  # retrieve objects that are members of a `Relation` field in your Parse class.
-  #
-  #  q.where :field.related_to => pointer
-  #
-  #  # find all Users who have liked this post object
-  #  post = Post.first
-  #  users = Parse::User.all :likes.related_to => post
-  #
-  class RelationQueryConstraint < Constraint
-    # @!method related_to
-    # A registered method on a symbol to create the constraint. Maps to Parse operator "$relatedTo".
-    # @example
-    #   q.where :field.related_to => pointer
-    # @return [RelationQueryConstraint]
-
-    # @!method rel
-    # Alias for {related_to}
-    # @return [RelationQueryConstraint]
-    contraint_keyword :$relatedTo
-    register :related_to
-    register :rel
-
-    # @return [Hash] the compiled constraint.
-    def build
-      # pointer = formatted_value
-      # unless pointer.is_a?(Parse::Pointer)
-      #   raise "Invalid Parse::Pointer passed to :related(#{@operation.operand}) constraint : #{pointer}"
-      # end
-      { :$relatedTo => { object: formatted_value, key: @operation.operand } }
+    # Equivalent to the `$relatedTo` Parse query operation. If you want to
+    # retrieve objects that are members of a `Relation` field in your Parse class.
+    #
+    #  q.where :field.related_to => pointer
+    #
+    #  # find all Users who have liked this post object
+    #  post = Post.first
+    #  users = Parse::User.all :likes.related_to => post
+    #
+    class RelationQueryConstraint < Constraint
+      # @!method related_to
+      # A registered method on a symbol to create the constraint. Maps to Parse operator "$relatedTo".
+      # @example
+      #   q.where :field.related_to => pointer
+      # @return [RelationQueryConstraint]
+
+      # @!method rel
+      # Alias for {related_to}
+      # @return [RelationQueryConstraint]
+      contraint_keyword :$relatedTo
+      register :related_to
+      register :rel
+
+      # @return [Hash] the compiled constraint.
+      def build
+        # pointer = formatted_value
+        # unless pointer.is_a?(Parse::Pointer)
+        #   raise "Invalid Parse::Pointer passed to :related(#{@operation.operand}) constraint : #{pointer}"
+        # end
+        { :$relatedTo => { object: formatted_value, key: @operation.operand } }
+      end
     end
-  end
 
-  # Equivalent to the `$inQuery` Parse query operation. Useful if you want to
-  # retrieve objects where a field contains an object that matches another query.
-  #
-  #  q.where :field.matches => query
-  #  # assume Post class has an image column.
-  #  q.where :post.matches => Post.where(:image.exists => true )
-  #
-  class InQueryConstraint < Constraint
-    # @!method matches
-    # A registered method on a symbol to create the constraint. Maps to Parse operator "$inQuery".
-    # @example
+    # Equivalent to the `$inQuery` Parse query operation. Useful if you want to
+    # retrieve objects where a field contains an object that matches another query.
+    #
     #  q.where :field.matches => query
-    # @return [InQueryConstraint]
-
-    # @!method in_query
-    # Alias for {matches}
-    # @return [InQueryConstraint]
-    contraint_keyword :$inQuery
-    register :matches
-    register :in_query
-  end
+    #  # assume Post class has an image column.
+    #  q.where :post.matches => Post.where(:image.exists => true )
+    #
+    class InQueryConstraint < Constraint
+      # @!method matches
+      # A registered method on a symbol to create the constraint. Maps to Parse operator "$inQuery".
+      # @example
+      #  q.where :field.matches => query
+      # @return [InQueryConstraint]
+
+      # @!method in_query
+      # Alias for {matches}
+      # @return [InQueryConstraint]
+      contraint_keyword :$inQuery
+      register :matches
+      register :in_query
+    end
 
-  # Equivalent to the `$notInQuery` Parse query operation. Useful if you want to
-  # retrieve objects where a field contains an object that does not match another query.
-  # This is the inverse of the {InQueryConstraint}.
-  #
-  #  q.where :field.excludes => query
-  #
-  #  q.where :post.excludes => Post.where(:image.exists => true
-  #
-  class NotInQueryConstraint < Constraint
-    # @!method excludes
-    # A registered method on a symbol to create the constraint. Maps to Parse operator "$notInQuery".
-    # @example
-    #   q.where :field.excludes => query
-    # @return [NotInQueryConstraint]
-
-    # @!method not_in_query
-    # Alias for {excludes}
-    # @return [NotInQueryConstraint]
-    contraint_keyword :$notInQuery
-    register :excludes
-    register :not_in_query
+    # Equivalent to the `$notInQuery` Parse query operation. Useful if you want to
+    # retrieve objects where a field contains an object that does not match another query.
+    # This is the inverse of the {InQueryConstraint}.
+    #
+    #  q.where :field.excludes => query
+    #
+    #  q.where :post.excludes => Post.where(:image.exists => true
+    #
+    class NotInQueryConstraint < Constraint
+      # @!method excludes
+      # A registered method on a symbol to create the constraint. Maps to Parse operator "$notInQuery".
+      # @example
+      #   q.where :field.excludes => query
+      # @return [NotInQueryConstraint]
+
+      # @!method not_in_query
+      # Alias for {excludes}
+      # @return [NotInQueryConstraint]
+      contraint_keyword :$notInQuery
+      register :excludes
+      register :not_in_query
 
-  end
+    end
 
-  # Equivalent to the `$nearSphere` Parse query operation. This is only applicable
-  # if the field is of type `GeoPoint`. This will query Parse and return a list of
-  # results ordered by distance with the nearest object being first.
-  #
-  #  q.where :field.near => geopoint
-  #
-  #  geopoint = Parse::GeoPoint.new(30.0, -20.0)
-  #  PlaceObject.all :location.near => geopoint
-  # If you wish to constrain the geospatial query to a maximum number of _miles_,
-  # you can utilize the `max_miles` method on a `Parse::GeoPoint` object. This
-  # is equivalent to the `$maxDistanceInMiles` constraint used with `$nearSphere`.
-  #
-  #  q.where :field.near => geopoint.max_miles(distance)
-  #  # or provide a triplet includes max miles constraint
-  #  q.where :field.near => [lat, lng, miles]
-  #
-  #  geopoint = Parse::GeoPoint.new(30.0, -20.0)
-  #  PlaceObject.all :location.near => geopoint.max_miles(10)
-  #
-  # @todo Add support $maxDistanceInKilometers (for kms) and $maxDistanceInRadians (for radian angle).
-  class NearSphereQueryConstraint < Constraint
-    # @!method near
-    # A registered method on a symbol to create the constraint. Maps to Parse operator "$nearSphere".
-    # @example
+    # Equivalent to the `$nearSphere` Parse query operation. This is only applicable
+    # if the field is of type `GeoPoint`. This will query Parse and return a list of
+    # results ordered by distance with the nearest object being first.
+    #
     #  q.where :field.near => geopoint
+    #
+    #  geopoint = Parse::GeoPoint.new(30.0, -20.0)
+    #  PlaceObject.all :location.near => geopoint
+    # If you wish to constrain the geospatial query to a maximum number of _miles_,
+    # you can utilize the `max_miles` method on a `Parse::GeoPoint` object. This
+    # is equivalent to the `$maxDistanceInMiles` constraint used with `$nearSphere`.
+    #
     #  q.where :field.near => geopoint.max_miles(distance)
-    # @return [NearSphereQueryConstraint]
-    contraint_keyword :$nearSphere
-    register :near
-
-    # @return [Hash] the compiled constraint.
-    def build
-      point = formatted_value
-      max_miles = nil
-      if point.is_a?(Array) && point.count > 1
-        max_miles = point[2] if point.count == 3
-        point = { __type: "GeoPoint", latitude: point[0], longitude: point[1] }
-      end
-      if max_miles.present? && max_miles > 0
-        return { @operation.operand => { key => point, :$maxDistanceInMiles => max_miles.to_f } }
+    #  # or provide a triplet includes max miles constraint
+    #  q.where :field.near => [lat, lng, miles]
+    #
+    #  geopoint = Parse::GeoPoint.new(30.0, -20.0)
+    #  PlaceObject.all :location.near => geopoint.max_miles(10)
+    #
+    # @todo Add support $maxDistanceInKilometers (for kms) and $maxDistanceInRadians (for radian angle).
+    class NearSphereQueryConstraint < Constraint
+      # @!method near
+      # A registered method on a symbol to create the constraint. Maps to Parse operator "$nearSphere".
+      # @example
+      #  q.where :field.near => geopoint
+      #  q.where :field.near => geopoint.max_miles(distance)
+      # @return [NearSphereQueryConstraint]
+      contraint_keyword :$nearSphere
+      register :near
+
+      # @return [Hash] the compiled constraint.
+      def build
+        point = formatted_value
+        max_miles = nil
+        if point.is_a?(Array) && point.count > 1
+          max_miles = point[2] if point.count == 3
+          point = { __type: "GeoPoint", latitude: point[0], longitude: point[1] }
+        end
+        if max_miles.present? && max_miles > 0
+          return { @operation.operand => { key => point, :$maxDistanceInMiles => max_miles.to_f } }
+        end
+        { @operation.operand => { key => point } }
       end
-      { @operation.operand => { key => point } }
-    end
 
-  end
+    end
 
-  # Equivalent to the `$within` Parse query operation and `$box` geopoint
-  # constraint. The rectangular bounding box is defined by a southwest point as
-  # the first parameter, followed by the a northeast point. Please note that Geo
-  # box queries that cross the international date lines are not currently
-  # supported by Parse.
-  #
-  #  q.where :field.within_box => [soutwestGeoPoint, northeastGeoPoint]
-  #
-  #  sw = Parse::GeoPoint.new 32.82, -117.23 # San Diego
-  #  ne = Parse::GeoPoint.new 36.12, -115.31 # Las Vegas
-  #
-  #  # get all PlaceObjects inside this bounding box
-  #  PlaceObject.all :location.within_box => [sw,ne]
-  #
-  class WithinGeoBoxQueryConstraint < Constraint
-    # @!method within_box
-    # A registered method on a symbol to create the constraint. Maps to Parse operator "$within".
-    # @example
+    # Equivalent to the `$within` Parse query operation and `$box` geopoint
+    # constraint. The rectangular bounding box is defined by a southwest point as
+    # the first parameter, followed by the a northeast point. Please note that Geo
+    # box queries that cross the international date lines are not currently
+    # supported by Parse.
+    #
     #  q.where :field.within_box => [soutwestGeoPoint, northeastGeoPoint]
-    # @return [WithinGeoBoxQueryConstraint]
-    contraint_keyword :$within
-    register :within_box
-
-    # @return [Hash] the compiled constraint.
-    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(ConstraintError, '[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]' )
+    #
+    #  sw = Parse::GeoPoint.new 32.82, -117.23 # San Diego
+    #  ne = Parse::GeoPoint.new 36.12, -115.31 # Las Vegas
+    #
+    #  # get all PlaceObjects inside this bounding box
+    #  PlaceObject.all :location.within_box => [sw,ne]
+    #
+    class WithinGeoBoxQueryConstraint < Constraint
+      # @!method within_box
+      # A registered method on a symbol to create the constraint. Maps to Parse operator "$within".
+      # @example
+      #  q.where :field.within_box => [soutwestGeoPoint, northeastGeoPoint]
+      # @return [WithinGeoBoxQueryConstraint]
+      contraint_keyword :$within
+      register :within_box
+
+      # @return [Hash] the compiled constraint.
+      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]' )
+        end
+        { @operation.operand => { :$within => { :$box => geopoint_values } } }
       end
-      { @operation.operand => { :$within => { :$box => geopoint_values } } }
     end
 
   end