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


88
89
90
91
# File 'lib/parse/model/pointer.rb', line 88

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


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

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.


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

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)

154
155
156
157
158
# File 'lib/parse/model/pointer.rb', line 154

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.


183
184
185
186
# File 'lib/parse/model/pointer.rb', line 183

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:


193
194
195
196
# File 'lib/parse/model/pointer.rb', line 193

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

#__typeModel::TYPE_POINTER

Returns:


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

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

#attributesHash

Returns:


104
105
106
# File 'lib/parse/model/pointer.rb', line 104

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.


79
80
81
# File 'lib/parse/model/pointer.rb', line 79

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:


145
146
147
148
149
# File 'lib/parse/model/pointer.rb', line 145

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.


137
138
139
# File 'lib/parse/model/pointer.rb', line 137

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)

169
170
171
# File 'lib/parse/model/pointer.rb', line 169

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

#json_hashHash

Returns serialized JSON structure.

Returns:

  • (Hash)

    serialized JSON structure


109
110
111
# File 'lib/parse/model/pointer.rb', line 109

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:


122
123
124
# File 'lib/parse/model/pointer.rb', line 122

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.


129
130
131
# File 'lib/parse/model/pointer.rb', line 129

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.


174
175
176
# File 'lib/parse/model/pointer.rb', line 174

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.


99
100
101
# File 'lib/parse/model/pointer.rb', line 99

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