Class: Parse::Pointer

Inherits:
Model
  • Object
show all
Defined in:
lib/parse/model/pointer.rb

Overview

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. 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.

Examples:

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.
Parse::User.pointer("123456") # => Parse::Pointer for "_User" class

See Also:

Direct Known Subclasses

Object

Constant Summary collapse

ATTRIBUTES =

The default attributes in a Parse Pointer hash.

{ __type: :string, className: :string, objectId: :string}.freeze

Constants inherited from Model

Model::CLASS_INSTALLATION, Model::CLASS_PRODUCT, Model::CLASS_ROLE, Model::CLASS_SESSION, Model::CLASS_USER, Model::ID, Model::KEY_CLASS_NAME, Model::KEY_CREATED_AT, Model::KEY_OBJECT_ID, Model::KEY_UPDATED_AT, Model::OBJECT_ID, Model::TYPE_ACL, Model::TYPE_BYTES, Model::TYPE_DATE, Model::TYPE_FIELD, Model::TYPE_FILE, Model::TYPE_GEOPOINT, Model::TYPE_NUMBER, Model::TYPE_OBJECT, Model::TYPE_POINTER, Model::TYPE_RELATION

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods inherited from Model

find_class

Methods included from Client::Connectable

#client

Constructor Details

#initialize(table, oid) ⇒ Pointer

A Parse pointer only requires the name of the remote Parse collection name, and the `objectId` of the record.

Parameters:

  • table (String)

    The Parse class name in the Parse database.

  • oid (String)

    The objectId


86
87
88
89
# File 'lib/parse/model/pointer.rb', line 86

def initialize(table, oid)
  @parse_class = table.to_s
  @id = oid.to_s
end

Instance Attribute Details

#idString Also known as: objectId

Returns the objectId field

Returns:

  • (String)

    the objectId field


73
74
75
# File 'lib/parse/model/pointer.rb', line 73

def id
  @id
end

#parse_classString

Returns the name of the collection for this Pointer.

Returns:

  • (String)

    the name of the collection for this Pointer.


71
72
73
# File 'lib/parse/model/pointer.rb', line 71

def parse_class
  @parse_class
end

Instance Method Details

#==(o) ⇒ Boolean Also known as: eql?

Two Parse::Pointers (or Parse::Objects) are equal if both of them have the same Parse class and the same id.

Returns:

  • (Boolean)

152
153
154
155
156
# File 'lib/parse/model/pointer.rb', line 152

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

#[](key) ⇒ Object

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.

Parameters:

  • key (String)

    the name of the property.

Returns:

  • (Object)

    the value for this key.


180
181
182
183
# File 'lib/parse/model/pointer.rb', line 180

def [](key)
  return nil unless [:id,:objectId,:className].include?(key.to_sym)
  send(key)
end

#[]=(key, value) ⇒ Object

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.

Parameters:

  • key (String)

    the name of the property.

Returns:


190
191
192
193
# File 'lib/parse/model/pointer.rb', line 190

def []=(key,value)
  return unless [:id,:objectId,:className].include?(key.to_sym)
  send("#{key}=",value)
end

#__typeModel::TYPE_POINTER

Returns:


76
# File 'lib/parse/model/pointer.rb', line 76

def __type; Parse::Model::TYPE_POINTER; end

#attributesHash

Returns:


102
103
104
# File 'lib/parse/model/pointer.rb', line 102

def attributes
  ATTRIBUTES
end

#classNameString

Returns the name of the Parse class for this pointer.

Returns:

  • (String)

    the name of the Parse class for this pointer.


77
78
79
# File 'lib/parse/model/pointer.rb', line 77

def parse_class
  @parse_class
end

#fetchParse::Object

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.

Returns:


143
144
145
146
147
# File 'lib/parse/model/pointer.rb', line 143

def fetch
  response = client.fetch_object(parse_class, id)
  return nil if response.error?
  response.result
end

#fetched?Boolean

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.

Returns:

  • (Boolean)

    true if not in pointer state.


135
136
137
# File 'lib/parse/model/pointer.rb', line 135

def fetched?
  present? && pointer? == false
end

#hashFixnum

Compute a hash-code for this object. It is calculated by combining the Parse class name, the Object#id field and any pending changes.

Two objects with the same content will have the same hash code (and will compare using eql?).

Returns:

  • (Fixnum)

166
167
168
# File 'lib/parse/model/pointer.rb', line 166

def hash
  "#{parse_class}#{id}#{changes.to_s}".hash
end

#json_hashHash

Returns serialized JSON structure

Returns:

  • (Hash)

    serialized JSON structure


107
108
109
# File 'lib/parse/model/pointer.rb', line 107

def json_hash
  JSON.parse to_json
end

#pointerPointer

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.

Examples:

user = Parse::User.first
user.pointer # => Parse::Pointer("_User", user.id)

Returns:

  • (Pointer)

    a new Pointer for this object.

See Also:


120
121
122
# File 'lib/parse/model/pointer.rb', line 120

def pointer
  Pointer.new parse_class, @id
end

#pointer?Boolean

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.

Returns:

  • (Boolean)

    true if instance is in pointer state.


127
128
129
# File 'lib/parse/model/pointer.rb', line 127

def pointer?
  present? && @created_at.blank? && @updated_at.blank?
end

#present?Boolean

Returns true if instance has a Parse class and an id.

Returns:

  • (Boolean)

    true if instance has a Parse class and an id.


171
172
173
# File 'lib/parse/model/pointer.rb', line 171

def present?
  parse_class.present? && @id.present?
end

#sigString

Returns a string representing the class and id of this instance.

Returns:

  • (String)

    a string representing the class and id of this instance.


97
98
99
# File 'lib/parse/model/pointer.rb', line 97

def sig
  "#{@parse_class}##{id || 'new'}"
end