parse-stack 1.8.0 → 1.8.1

data/lib/parse/model/geopoint.rb

@@ -24,7 +24,7 @@ module Parse
   #
   class GeoPoint < Model
     # The default attributes in a Parse GeoPoint hash.
-    ATTRIBUTES = {  __type: :string, latitude: :float, longitude: :float }.freeze
+    ATTRIBUTES = { __type: :string, latitude: :float, longitude: :float }.freeze
 
     # @return [Float] latitude value between -90.0 and 90.0
     attr_accessor :latitude
@@ -47,9 +47,10 @@ module Parse
     alias_method :lat, :latitude
     alias_method :lng, :longitude
     # @return [Model::TYPE_GEOPOINT]
-    def self.parse_class; TYPE_GEOPOINT; end;
+    def self.parse_class; TYPE_GEOPOINT; end
     # @return [Model::TYPE_GEOPOINT]
-    def parse_class; self.class.parse_class; end;
+    def parse_class; self.class.parse_class; end
+
     alias_method :__type, :parse_class
 
     # The initializer can create a GeoPoint with a hash, array or values.
@@ -77,7 +78,6 @@ module Parse
 
     # @!visibility private
     def _validate_point
-
       unless @latitude.nil? || @latitude.between?(LAT_MIN, LAT_MAX)
         warn "[Parse::GeoPoint] Latitude (#{@latitude}) is not between #{LAT_MIN}, #{LAT_MAX}!"
         warn "Attempting to use GeoPoint’s with latitudes outside these ranges will raise an exception in a future release."
@@ -87,7 +87,6 @@ module Parse
         warn "[Parse::GeoPoint] Longitude (#{@longitude}) is not between #{LNG_MIN}, #{LNG_MAX}!"
         warn "Attempting to use GeoPoint’s with longitude outside these ranges will raise an exception in a future release."
       end
-
     end
 
     # @return [Hash] attributes for a Parse GeoPoint.
@@ -99,7 +98,7 @@ module Parse
     # @return [Array] containing [lat,lng,miles]
     def max_miles(m)
       m = 0 if m.nil?
-      [@latitude,@longitude,m]
+      [@latitude, @longitude, m]
     end
 
     def latitude=(l)
@@ -118,7 +117,7 @@ module Parse
       if h.is_a?(Hash)
         h = h.symbolize_keys
         @latitude = h[:latitude].to_f || h[:lat].to_f || @latitude
-        @longitude = h[:longitude].to_f || h[:lng].to_f ||  @longitude
+        @longitude = h[:longitude].to_f || h[:lng].to_f || @longitude
       elsif h.is_a?(Array) && h.count == 2
         @latitude = h.first.to_f
         @longitude = h.last.to_f
@@ -142,7 +141,7 @@ module Parse
     # Returns a tuple containing latitude and longitude
     # @return [Array]
     def to_a
-      [@latitude,@longitude]
+      [@latitude, @longitude]
     end
 
     # @!visibility private
@@ -161,7 +160,7 @@ module Parse
     # is longitude instead of a GeoPoint.
     # @return [Float] number of miles between geopoints.
     # @see #distance_in_km
-    def distance_in_miles(geopoint,lng = nil)
+    def distance_in_miles(geopoint, lng = nil)
       distance_in_km(geopoint, lng) * 0.621371
     end
 
@@ -175,12 +174,12 @@ module Parse
     # @param lng [Float] Longitude assuming that the first parameter is a latitude instead of a GeoPoint.
     # @return [Float] number of miles between geopoints.
     # @see #distance_in_miles
-    def distance_in_km(geopoint,lng = nil)
+    def distance_in_km(geopoint, lng = nil)
       unless geopoint.is_a?(Parse::GeoPoint)
         geopoint = Parse::GeoPoint.new(geopoint, lng)
       end
 
-      dtor = Math::PI/180
+      dtor = Math::PI / 180
       r = 6378.14
       r_lat1 = self.latitude * dtor
       r_lng1 = self.longitude * dtor
@@ -190,13 +189,10 @@ module Parse
       delta_lat = r_lat1 - r_lat2
       delta_lng = r_lng1 - r_lng2
 
-      a = (Math::sin(delta_lat/2.0) ** 2).to_f + (Math::cos(r_lat1) * Math::cos(r_lat2) * ( Math::sin(delta_lng/2.0) ** 2 ) )
-      c = 2.0 * Math::atan2(Math::sqrt(a), Math::sqrt(1.0-a))
+      a = (Math::sin(delta_lat / 2.0) ** 2).to_f + (Math::cos(r_lat1) * Math::cos(r_lat2) * (Math::sin(delta_lng / 2.0) ** 2))
+      c = 2.0 * Math::atan2(Math::sqrt(a), Math::sqrt(1.0 - a))
       d = r * c
       d
     end
-
-
   end
-
 end

data/lib/parse/model/model.rb

@@ -1,12 +1,12 @@
 # encoding: UTF-8
 # frozen_string_literal: true
 
-require 'active_model'
-require 'active_support'
-require 'active_support/inflector'
-require 'active_support/core_ext/object'
-require 'active_model_serializers'
-require_relative '../client'
+require "active_model"
+require "active_support"
+require "active_support/inflector"
+require "active_support/core_ext/object"
+require "active_model_serializers"
+require_relative "../client"
 
 module Parse
   # Find a corresponding Parse::Object subclass for this string or symbol
@@ -21,61 +21,59 @@ module Parse
   # serialization, dirty tracking, callbacks, etc.
   # @see ActiveModel
   class Model
-
     include Client::Connectable # allows easy default Parse::Client access
     include ::ActiveModel::Model
     include ::ActiveModel::Serializers::JSON # support for JSON Serializers
     include ::ActiveModel::Dirty # adds dirty tracking support
     include ::ActiveModel::Conversion
-    extend  ::ActiveModel::Callbacks # callback support on save, update, delete, etc.
-    extend  ::ActiveModel::Naming # provides the methods for getting class names from Model classes
+    extend ::ActiveModel::Callbacks # callback support on save, update, delete, etc.
+    extend ::ActiveModel::Naming # provides the methods for getting class names from Model classes
 
     # The name of the field in a hash that contains information about the type
     # of data the hash represents.
-    TYPE_FIELD = '__type'.freeze
+    TYPE_FIELD = "__type".freeze
 
     # The objectId field in Parse Objects.
-    OBJECT_ID   = 'objectId'.freeze
+    OBJECT_ID = "objectId".freeze
     # @see OBJECT_ID
     ID = "id".freeze
 
     # The key field for getting class information.
-    KEY_CLASS_NAME  = 'className'.freeze
+    KEY_CLASS_NAME = "className".freeze
     # @deprecated Use OBJECT_ID instead.
-    KEY_OBJECT_ID   = 'objectId'.freeze
+    KEY_OBJECT_ID = "objectId".freeze
     # The key field for getting the created at date of an object hash.
-    KEY_CREATED_AT  = 'createdAt'
+    KEY_CREATED_AT = "createdAt"
     # The key field for getting the updated at date of an object hash.
-    KEY_UPDATED_AT  = 'updatedAt'
+    KEY_UPDATED_AT = "updatedAt"
     # The collection for Users in Parse. Used by Parse::User.
-    CLASS_USER      = '_User'
+    CLASS_USER = "_User"
     # The collection for Installations in Parse. Used by Parse::Installation.
-    CLASS_INSTALLATION = '_Installation'
+    CLASS_INSTALLATION = "_Installation"
     # The collection for revocable Sessions in Parse. Used by Parse::Session.
-    CLASS_SESSION = '_Session'
+    CLASS_SESSION = "_Session"
     # The collection for Roles in Parse. Used by Parse::Role.
-    CLASS_ROLE = '_Role'
+    CLASS_ROLE = "_Role"
     # The collection for to store Products (in-App purchases) in Parse. Used by Parse::Product.
-    CLASS_PRODUCT = '_Product'
+    CLASS_PRODUCT = "_Product"
     # The type label for hashes containing file data. Used by Parse::File.
-    TYPE_FILE = 'File'
+    TYPE_FILE = "File"
     # The type label for hashes containing geopoints. Used by Parse::GeoPoint.
-    TYPE_GEOPOINT = 'GeoPoint'
+    TYPE_GEOPOINT = "GeoPoint"
     # The type label for hashes containing a Parse object. Used by Parse::Object and subclasses.
-    TYPE_OBJECT = 'Object'
+    TYPE_OBJECT = "Object"
     # The type label for hashes containing a Parse date object. Used by Parse::Date.
-    TYPE_DATE = 'Date'
+    TYPE_DATE = "Date"
     # The type label for hashes containing 'byte' data. Used by Parse::Bytes.
-    TYPE_BYTES = 'Bytes'
+    TYPE_BYTES = "Bytes"
     # The type label for hashes containing ACL data. Used by Parse::ACL
-    TYPE_ACL = 'ACL'
+    TYPE_ACL = "ACL"
     # The type label for hashes storing numeric data.
-    TYPE_NUMBER = 'Number'
+    TYPE_NUMBER = "Number"
     # The type label for hashes containing a Parse pointer.
-    TYPE_POINTER = 'Pointer'
+    TYPE_POINTER = "Pointer"
     # The type label for hashes representing relational data.
-    TYPE_RELATION = 'Relation'
-
+    TYPE_RELATION = "Relation"
 
     # To support being able to have different ruby class names from the 'table'
     # names used in Parse, we will need to have a dynamic lookup system where
@@ -115,7 +113,6 @@ module Parse
       def raise_on_save_failure=(bool)
         @global_raise_on_save_failure = bool
       end
-
     end
 
     # Find a Parse::Model subclass matching this type or Pares collection name.
@@ -149,11 +146,8 @@ module Parse
       @@model_cache[str] ||= Parse::Object.descendants.find do |f|
         f.parse_class == str || f.parse_class == "_#{str}"
       end
-
     end
-
   end
-
 end
 
 # Add extensions to the String class.
@@ -172,9 +166,9 @@ class String
   # @return [String]
   # @see Parse::Query.field_formatter
   def columnize
-     return Parse::Model::OBJECT_ID if self == Parse::Model::ID
-     u = '_'.freeze
-     (first == u ? sub(u,'') : self).camelize(:lower)
+    return Parse::Model::OBJECT_ID if self == Parse::Model::ID
+    u = "_".freeze
+    (first == u ? sub(u, "") : self).camelize(:lower)
   end
 
   # Convert a string to a Parse class name. This method tries to find a

data/lib/parse/model/object.rb

@@ -1,42 +1,41 @@
 # encoding: UTF-8
 # frozen_string_literal: true
 
-require 'active_model'
-require 'active_support'
-require 'active_support/inflector'
-require 'active_support/core_ext'
-require 'active_support/core_ext/object'
-require 'active_support/core_ext/string'
-require 'active_model_serializers'
-require 'time'
-require 'open-uri'
-
-require_relative '../client'
-require_relative 'model'
-require_relative 'pointer'
-require_relative 'geopoint'
-require_relative 'file'
-require_relative 'bytes'
-require_relative 'date'
-require_relative 'time_zone'
-require_relative 'acl'
-require_relative 'push'
-require_relative 'core/actions'
-require_relative 'core/fetching'
-require_relative 'core/querying'
-require_relative 'core/schema'
-require_relative 'core/properties'
-require_relative 'core/errors'
-require_relative 'core/builder'
-require_relative 'associations/has_one'
-require_relative 'associations/belongs_to'
-require_relative 'associations/has_many'
-
+require "active_model"
+require "active_support"
+require "active_support/inflector"
+require "active_support/core_ext"
+require "active_support/core_ext/object"
+require "active_support/core_ext/string"
+require "active_model_serializers"
+require "time"
+require "open-uri"
+
+require_relative "../client"
+require_relative "model"
+require_relative "pointer"
+require_relative "geopoint"
+require_relative "file"
+require_relative "bytes"
+require_relative "date"
+require_relative "time_zone"
+require_relative "acl"
+require_relative "push"
+require_relative "core/actions"
+require_relative "core/fetching"
+require_relative "core/querying"
+require_relative "core/schema"
+require_relative "core/properties"
+require_relative "core/errors"
+require_relative "core/builder"
+require_relative "associations/has_one"
+require_relative "associations/belongs_to"
+require_relative "associations/has_many"
 
 module Parse
   # @return [Array] an array of registered Parse::Object subclasses.
   def self.registered_classes
-      Parse::Object.descendants.map(&:parse_class).uniq
+    Parse::Object.descendants.map(&:parse_class).uniq
   end
 
   # @return [Array<Hash>] the list of all schemas for this application.
@@ -65,7 +64,7 @@ module Parse
   # Alias shorter names of core Parse class names.
   # Ex, alias Parse::User to User, Parse::Installation to Installation, etc.
   def self.use_shortnames!
-    require_relative 'shortnames'
+    require_relative "shortnames"
   end
 
   # This is the core class for all app specific Parse table subclasses. This class
@@ -139,7 +138,7 @@ module Parse
     BASE_OBJECT_CLASS = "Parse::Object".freeze
 
     # @return [Model::TYPE_OBJECT]
-    def __type; Parse::Model::TYPE_OBJECT; end;
+    def __type; Parse::Model::TYPE_OBJECT; end
 
     # Default ActiveModel::Callbacks
     # @!group Callbacks
@@ -183,7 +182,6 @@ module Parse
     # the remote Parse table is named 'Artist'. You may override this behavior by utilizing the `parse_class(<className>)` method
     # to set it to something different.
     class << self
-
       attr_accessor :parse_class
       attr_reader :default_acls
 
@@ -253,7 +251,6 @@ module Parse
       def acl(acls, owner: nil)
         raise "[#{self}.acl DEPRECATED] - Use `#{self}.default_acl` instead."
       end
-
     end # << self
 
     # @return [String] the Parse class for this object.
@@ -261,6 +258,7 @@ module Parse
     def parse_class
       self.class.parse_class
     end
+
     alias_method :className, :parse_class
 
     # @return [Hash] the schema structure for this Parse collection from the server.
@@ -347,7 +345,7 @@ module Parse
     # @param opts [Hash] a set of options to send to fetch!
     # @see Fetching#fetch!
     def reload!(opts = {})
-    # get the values from the persistence layer
+      # get the values from the persistence layer
       fetch!(opts)
       clear_changes!
     end
@@ -436,7 +434,7 @@ module Parse
     # @return [String] a pretty-formatted JSON string
     # @see JSON.pretty_generate
     def pretty
-      JSON.pretty_generate( as_json )
+      JSON.pretty_generate(as_json)
     end
 
     # clear all change and dirty tracking information.
@@ -483,10 +481,10 @@ module Parse
         o = Parse::Pointer.new className, (json[Parse::Model::OBJECT_ID] || json[:objectId])
       end
       return o
-    # rescue NameError => e
-    #   puts "Parse::Object.build constant class error: #{e}"
-    # rescue Exception => e
-    #   puts "Parse::Object.build error: #{e}"
+      # rescue NameError => e
+      #   puts "Parse::Object.build constant class error: #{e}"
+      # rescue Exception => e
+      #   puts "Parse::Object.build error: #{e}"
     end
 
     # @!attribute id
@@ -521,13 +519,11 @@ module Parse
     # @param key (see Parse::Object#[])
     # @param value [Object] the value to set this property.
     # @return [Object] the value passed in.
-    def []=(key,value)
+    def []=(key, value)
       return unless self.class.fields[key.to_sym].present?
-      send("#{key}=",value)
+      send("#{key}=", value)
     end
-
   end
-
 end
 
 class Hash
@@ -540,7 +536,6 @@ class Hash
   def parse_object
     Parse::Object.build(self)
   end
-
 end
 
 class Array
@@ -565,12 +560,11 @@ class Array
   def parse_ids
     parse_objects.map(&:id)
   end
-
 end
 
 # Load all the core classes.
-require_relative 'classes/installation'
-require_relative 'classes/product'
-require_relative 'classes/role'
-require_relative 'classes/session'
-require_relative 'classes/user'
+require_relative "classes/installation"
+require_relative "classes/product"
+require_relative "classes/role"
+require_relative "classes/session"
+require_relative "classes/user"

data/lib/parse/model/pointer.rb

@@ -1,199 +1,200 @@
 # encoding: UTF-8
 # frozen_string_literal: true
 
-require 'active_model'
-require 'active_support'
-require 'active_support/inflector'
-require 'active_support/core_ext'
-require 'active_model_serializers'
-require_relative 'model'
+require "active_model"
+require "active_support"
+require "active_support/inflector"
+require "active_support/core_ext"
+require "active_model_serializers"
+require_relative "model"
+
 module Parse
 
-    # The Pointer class represents the pointer type in Parse and is the superclass
-    # of Parse::Object types. A pointer can be considered a type of Parse::Object
-    # in which only the class name and id is known. In most cases, you may not
-    # deal with Parse::Pointer objects directly if you have defined all your
-    # Parse::Object subclasses.
-    #
-    # A `Parse::Pointer` only contains data about the specific Parse class and
-    # the `id` for the object. Therefore, creating an instance of any
-    # Parse::Object subclass with only the `:id` field set will be
-    # considered in "pointer" state even though its specific class is not
-    # `Parse::Pointer` type. The only case that you may have a Parse::Pointer
-    # is in the case where an object was received for one of your classes and
-    # the framework has no registered class handler for it.
-    # Assume you have the tables `Post`, `Comment` and `Author` defined in your
-    # remote Parse database, but have only defined `Post` and `Commentary`
-    # locally.
-    # @example
-    #   class Post < Parse::Object
-    #   end
-    #
-    #   class Commentary < Parse::Object
-    # 	  belongs_to :post
-    # 	  belongs_to :author
-    #   end
-    #
-    #   comment = Commentary.first
-    #   comment.post? # true because it is non-nil
-    #   comment.artist? # true because it is non-nil
-    #
-    #   # both are true because they are in a Pointer state
-    #   comment.post.pointer? # true
-    #   comment.author.pointer? # true
-    #
-    #   # we have defined a Post class handler
-    #   comment.post # <Post @parse_class="Post", @id="xdqcCqfngz">
-    #
-    #   # we have not defined an Author class handler
-    #   comment.author # <Parse::Pointer @parse_class="Author", @id="hZLbW6ofKC">
-    #
-    #
-    #   comment.post.fetch # fetch the relation
-    #   comment.post.pointer? # false, it is now a full object.
-    #
-    # The effect is that for any unknown classes that the framework encounters,
-    # it will generate Parse::Pointer instances until you define those classes
-    # with valid properties and associations. While this might be ok for some
-    # classes you do not use, we still recommend defining all your Parse classes
-    # locally in the framework.
-    #
-    # Once you have a subclass, you may also create a Parse::Pointer object using
-    # the _pointer_ method.
-    # @example
-    #   Parse::User.pointer("123456") # => Parse::Pointer for "_User" class
-    #
-    # @see Parse::Object
-    class Pointer < Model
-      # 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
-      # @return [String] the objectId field
-      attr_accessor :id
-
-      # @return [Model::TYPE_POINTER]
-      def __type; Parse::Model::TYPE_POINTER; end;
-      alias_method :className, :parse_class
-      # A Parse object as a className field and objectId. In ruby, we will use the
-      # id attribute method, but for usability, we will also alias it to objectId
-      alias_method :objectId, :id
-
-      # A Parse pointer only requires the name of the remote Parse collection name,
-      # and the `objectId` of the record.
-      # @param table [String] The Parse class name in the Parse database.
-      # @param oid [String] The objectId
-      def initialize(table, oid)
-        @parse_class = table.to_s
-        @id = oid.to_s
-      end
+  # The Pointer class represents the pointer type in Parse and is the superclass
+  # of Parse::Object types. A pointer can be considered a type of Parse::Object
+  # in which only the class name and id is known. In most cases, you may not
+  # deal with Parse::Pointer objects directly if you have defined all your
+  # Parse::Object subclasses.
+  #
+  # A `Parse::Pointer` only contains data about the specific Parse class and
+  # the `id` for the object. Therefore, creating an instance of any
+  # Parse::Object subclass with only the `:id` field set will be
+  # considered in "pointer" state even though its specific class is not
+  # `Parse::Pointer` type. The only case that you may have a Parse::Pointer
+  # is in the case where an object was received for one of your classes and
+  # the framework has no registered class handler for it.
+  # Assume you have the tables `Post`, `Comment` and `Author` defined in your
+  # remote Parse database, but have only defined `Post` and `Commentary`
+  # locally.
+  # @example
+  #   class Post < Parse::Object
+  #   end
+  #
+  #   class Commentary < Parse::Object
+  # 	  belongs_to :post
+  # 	  belongs_to :author
+  #   end
+  #
+  #   comment = Commentary.first
+  #   comment.post? # true because it is non-nil
+  #   comment.artist? # true because it is non-nil
+  #
+  #   # both are true because they are in a Pointer state
+  #   comment.post.pointer? # true
+  #   comment.author.pointer? # true
+  #
+  #   # we have defined a Post class handler
+  #   comment.post # <Post @parse_class="Post", @id="xdqcCqfngz">
+  #
+  #   # we have not defined an Author class handler
+  #   comment.author # <Parse::Pointer @parse_class="Author", @id="hZLbW6ofKC">
+  #
+  #
+  #   comment.post.fetch # fetch the relation
+  #   comment.post.pointer? # false, it is now a full object.
+  #
+  # The effect is that for any unknown classes that the framework encounters,
+  # it will generate Parse::Pointer instances until you define those classes
+  # with valid properties and associations. While this might be ok for some
+  # classes you do not use, we still recommend defining all your Parse classes
+  # locally in the framework.
+  #
+  # Once you have a subclass, you may also create a Parse::Pointer object using
+  # the _pointer_ method.
+  # @example
+  #   Parse::User.pointer("123456") # => Parse::Pointer for "_User" class
+  #
+  # @see Parse::Object
+  class Pointer < Model
+    # 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
+    # @return [String] the objectId field
+    attr_accessor :id
+
+    # @return [Model::TYPE_POINTER]
+    def __type; Parse::Model::TYPE_POINTER; end
+
+    alias_method :className, :parse_class
+    # A Parse object as a className field and objectId. In ruby, we will use the
+    # id attribute method, but for usability, we will also alias it to objectId
+    alias_method :objectId, :id
+
+    # A Parse pointer only requires the name of the remote Parse collection name,
+    # and the `objectId` of the record.
+    # @param table [String] The Parse class name in the Parse database.
+    # @param oid [String] The objectId
+    def initialize(table, oid)
+      @parse_class = table.to_s
+      @id = oid.to_s
+    end
 
-      # @return [String] the name of the collection for this Pointer.
-      def parse_class
-        @parse_class
-      end
+    # @return [String] the name of the collection for this Pointer.
+    def parse_class
+      @parse_class
+    end
 
-      # @return [String] a string representing the class and id of this instance.
-      def sig
-        "#{@parse_class}##{id || 'new'}"
-      end
+    # @return [String] a string representing the class and id of this instance.
+    def sig
+      "#{@parse_class}##{id || "new"}"
+    end
 
-      # @return [Hash]
-      def attributes
-        ATTRIBUTES
-      end
+    # @return [Hash]
+    def attributes
+      ATTRIBUTES
+    end
 
-      # @return [Hash] serialized JSON structure
-      def json_hash
-        JSON.parse to_json
-      end
+    # @return [Hash] serialized JSON structure
+    def json_hash
+      JSON.parse to_json
+    end
 
-      # Create a new pointer with the current class name and id. While this may not make sense
-      # for a pointer instance, Parse::Object subclasses use this inherited method to turn themselves into
-      # pointer objects.
-      # @example
-      #  user = Parse::User.first
-      #  user.pointer # => Parse::Pointer("_User", user.id)
-      #
-      # @return [Pointer] a new Pointer for this object.
-      # @see Parse::Object
-      def pointer
-        Pointer.new parse_class, @id
-      end
+    # Create a new pointer with the current class name and id. While this may not make sense
+    # for a pointer instance, Parse::Object subclasses use this inherited method to turn themselves into
+    # pointer objects.
+    # @example
+    #  user = Parse::User.first
+    #  user.pointer # => Parse::Pointer("_User", user.id)
+    #
+    # @return [Pointer] a new Pointer for this object.
+    # @see Parse::Object
+    def pointer
+      Pointer.new parse_class, @id
+    end
 
-      # Whether this instance is in pointer state. A pointer is determined
-      # if we have a parse class and an id, but no created_at or updated_at fields.
-      # @return [Boolean] true if instance is in pointer state.
-      def pointer?
-        present? && @created_at.blank? && @updated_at.blank?
-      end
+    # Whether this instance is in pointer state. A pointer is determined
+    # if we have a parse class and an id, but no created_at or updated_at fields.
+    # @return [Boolean] true if instance is in pointer state.
+    def pointer?
+      present? && @created_at.blank? && @updated_at.blank?
+    end
 
-      # Returns true if the data for this instance has been fetched. Because of some autofetching
-      # mechanisms, this is useful to know whether the object already has data without actually causing
-      # a fetch of the data.
-      # @return [Boolean] true if not in pointer state.
-      def fetched?
-        present? && pointer? == false
-      end
+    # Returns true if the data for this instance has been fetched. Because of some autofetching
+    # mechanisms, this is useful to know whether the object already has data without actually causing
+    # a fetch of the data.
+    # @return [Boolean] true if not in pointer state.
+    def fetched?
+      present? && pointer? == false
+    end
 
-      # This method is a general implementation that gets overriden by Parse::Object subclass.
-      # Given the class name and the id, we will go to Parse and fetch the actual record, returning the
-      # JSON object.
-      # @return [Parse::Object] the fetched Parse::Object, nil otherwise.
-      def fetch
-        response = client.fetch_object(parse_class, id)
-        return nil if response.error?
-        response.result
-      end
+    # This method is a general implementation that gets overriden by Parse::Object subclass.
+    # Given the class name and the id, we will go to Parse and fetch the actual record, returning the
+    # JSON object.
+    # @return [Parse::Object] the fetched Parse::Object, nil otherwise.
+    def fetch
+      response = client.fetch_object(parse_class, id)
+      return nil if response.error?
+      response.result
+    end
 
-      # Two Parse::Pointers (or Parse::Objects) are equal if both of them have
-      # the same Parse class and the same id.
-      # @return [Boolean]
-      def ==(o)
-        return false unless o.is_a?(Pointer)
-        #only equal if the Parse class and object ID are the same.
-        self.parse_class == o.parse_class && id == o.id
-      end
-      alias_method :eql?, :==
-
-      # Compute a hash-code for this object. It is calculated
-      # by combining the Parse class name, the {Parse::Object#id} field and
-      # any pending changes.
-      #
-      # Two objects with the same content will have the same hash code
-      # (and will compare using eql?).
-      # @return [Fixnum]
-      def hash
-        "#{parse_class}#{id}#{changes.to_s}".hash
-      end
+    # Two Parse::Pointers (or Parse::Objects) are equal if both of them have
+    # the same Parse class and the same id.
+    # @return [Boolean]
+    def ==(o)
+      return false unless o.is_a?(Pointer)
+      #only equal if the Parse class and object ID are the same.
+      self.parse_class == o.parse_class && id == o.id
+    end
 
-      # @return [Boolean] true if instance has a Parse class and an id.
-      def present?
-        parse_class.present? && @id.present?
-      end
+    alias_method :eql?, :==
 
-      # 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
+    # Compute a hash-code for this object. It is calculated
+    # by combining the Parse class name, the {Parse::Object#id} field and
+    # any pending changes.
+    #
+    # Two objects with the same content will have the same hash code
+    # (and will compare using eql?).
+    # @return [Fixnum]
+    def hash
+      "#{parse_class}#{id}#{changes.to_s}".hash
+    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
+    # @return [Boolean] true if instance has a Parse class and an id.
+    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
 
 # extensions