Class: ArangoDocument

Inherits:
ArangoServer show all
Defined in:
lib/ArangoRB_Doc.rb

Overview

DOCUMENT ====

Direct Known Subclasses

ArangoEdge, ArangoVertex

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from ArangoServer

address, async, async=, batch, cancelAsync, changePropertyWAL, checkPort, cluster, cluster=, clusterRoundtrip, clusterStatistics, collection, collection=, createDumpBatch, database, database=, databaseVersion, databases, default_server, destroyAllAsync, destroyAsync, destroyCluster, destroyDumpBatch, destroyExpiredAsync, echo, endpoints, execute, executeCluster, executeClusterHead, executeClusterPut, fetchAsync, flushWAL, graph, graph=, log, pendingAsync, prolongDumpBatch, propertyWAL, reload, request, restart, retrieveAsync, retrieveDoneAsync, retrievePendingAsync, return_result, return_result_async, role, server, serverId, shutdown, sleep, statistics, tasks, test, time, transactions, updateCluster, user, user=, username, users, verbose, verbose=, version

Constructor Details

#initialize(key: nil, collection: @@collection, database: @@database, body: {}, from: nil, to: nil) ⇒ ArangoDocument

TESTED



4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
 
# File 'lib/ArangoRB_Doc.rb', line 4

def initialize(key: nil, collection: @@collection, database: @@database, body: {}, from: nil, to: nil) # TESTED
  if collection.is_a?(String)
    @collection = collection
  elsif collection.is_a?(ArangoCollection)
    @collection = collection.collection
  else
    raise "collection should be a String or an ArangoCollection instance, not a #{collection.class}"
  end

  if database.is_a?(String)
    @database = database
  elsif database.is_a?(ArangoDatabase)
    @database = database.database
  else
    raise "database should be a String or an ArangoDatabase instance, not a #{database.class}"
  end

  if key.is_a?(String) || key.nil?
    @key = key
    unless key.nil?
      body["_key"] = @key
      @id = "#{@collection}/#{@key}"
    end
  elsif key.is_a?(ArangoDocument)
    @key = key.key
    @id = key.id
  else
    raise "key should be a String, not a #{key.class}"
  end

  if body.is_a?(Hash)
    @body = body
  else
    raise "body should be a Hash, not a #{body.class}"
  end

  if from.is_a?(String)
    @body["_from"] = from
  elsif from.is_a?(ArangoDocument)
    @body["_from"] = from.id
  elsif from.nil?
  else
    raise "from should be a String or an ArangoDocument instance, not a #{from.class}"
  end

  if to.is_a?(String)
    @body["_to"] = to
  elsif to.is_a?(ArangoDocument)
    @body["_to"] = to.id
  elsif to.nil?
  else
    raise "to should be a String or an ArangoDocument instance, not a #{to.class}"
  end

  @idCache = "DOC_#{@id}"
end

Instance Attribute Details

#body ⇒ Object (readonly)

Returns the value of attribute body.



61
62
63
 
# File 'lib/ArangoRB_Doc.rb', line 61

def body
  @body
end

#id ⇒ Object (readonly)

Returns the value of attribute id.



61
62
63
 
# File 'lib/ArangoRB_Doc.rb', line 61

def id
  @id
end

#idCache ⇒ Object (readonly)

Returns the value of attribute idCache.



61
62
63
 
# File 'lib/ArangoRB_Doc.rb', line 61

def idCache
  @idCache
end

#key ⇒ Object (readonly) Also known as: name

Returns the value of attribute key.



61
62
63
 
# File 'lib/ArangoRB_Doc.rb', line 61

def key
  @key
end

Class Method Details

.create(body: {}, waitForSync: nil, returnNew: nil, database: @@database, collection: @@collection) ⇒ Object

TESTED



152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
 
# File 'lib/ArangoRB_Doc.rb', line 152

def self.create(body: {}, waitForSync: nil, returnNew: nil, database: @@database, collection: @@collection)  # TESTED
  collection = collection.is_a?(String) ? collection : collection.collection
  database = database.is_a?(String) ? database : database.database
  query = {"waitForSync" => waitForSync, "returnNew" => returnNew}.delete_if{|k,v| v.nil?}
  unless body.is_a? Array
    request = @@request.merge({ :body => body.to_json, :query => query })
    result = post("/_db/#{database}/_api/document/#{collection}", request)
    return result.headers["x-arango-async-id"] if @@async == "store"
    return true if @@async
    result = result.parsed_response
    @@verbose ? result : result["error"] ? result["errorMessage"] : ArangoDocument.new(key: result["_key"], collection: result["_id"].split("/")[0], body: body)
  else
    body = body.map{|x| x.is_a?(Hash) ? x : x.is_a?(ArangoDocument) ? x.body : nil}
    request = @@request.merge({ :body => body.to_json, :query => query })
    result = post("/_db/#{database}/_api/document/#{collection}", request)
    return result.headers["x-arango-async-id"] if @@async == "store"
    return true if @@async
    result = result.parsed_response
    i = -1
    @@verbose ? result : !result.is_a?(Array) ? result["errorMessage"] : result.map{|x| ArangoDocument.new(key: x["_key"], collection: collection, database: database, body: body[i+=1])}
  end
end

.create_edge(body: {}, from:, to:, waitForSync: nil, returnNew: nil, database: @@database, collection: @@collection) ⇒ Object

TESTED



191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
 
# File 'lib/ArangoRB_Doc.rb', line 191

def self.create_edge(body: {}, from:, to:, waitForSync: nil, returnNew: nil, database: @@database, collection: @@collection)  # TESTED
  edges = []
  from = [from] unless from.is_a? Array
  to = [to] unless to.is_a? Array
  body = [body] unless body.is_a? Array
  body = body.map{|x| x.is_a?(Hash) ? x : x.is_a?(ArangoDocument) ? x.body : nil}
  body.each do |b|
    from.each do |f|
      b["_from"] = f.is_a?(String) ? f : f.id
      to.each do |t|
        b["_to"] = t.is_a?(String) ? t : t.id
        edges << b.clone
      end
    end
  end
  edges = edges[0] if edges.length == 1
  ArangoDocument.create(body: edges, waitForSync: waitForSync, returnNew: returnNew, database: database, collection: collection)
end

Instance Method Details

#any(edgeCollection) ⇒ Object

TESTED



112
113
114
 
# File 'lib/ArangoRB_Doc.rb', line 112

def any(edgeCollection)  # TESTED
  self.retrieve_edges collection: edgeCollection
end

#collection ⇒ Object 



78
79
80
 
# File 'lib/ArangoRB_Doc.rb', line 78

def collection
  ArangoCollection.new(collection: @collection, database: @database)
end

#create(body: {}, waitForSync: nil, returnNew: nil) ⇒ Object

POST ====



141
142
143
144
145
146
147
148
 
# File 'lib/ArangoRB_Doc.rb', line 141

def create(body: {}, waitForSync: nil, returnNew: nil)  # TESTED
  body = @body.merge(body)
  query = {"waitForSync" => waitForSync, "returnNew" => returnNew}.delete_if{|k,v| v.nil?}
  body["_key"] = @key if body["_key"].nil? && !key.nil?
  request = @@request.merge({ :body => @body.to_json, :query => query })
  result = self.class.post("/_db/#{@database}/_api/document/#{@collection}", request)
  return_result result: result, body: @body
end

#create_document ⇒ Object

POST ====



149
150
151
152
153
154
155
156
 
# File 'lib/ArangoRB_Doc.rb', line 149

def create(body: {}, waitForSync: nil, returnNew: nil)  # TESTED
  body = @body.merge(body)
  query = {"waitForSync" => waitForSync, "returnNew" => returnNew}.delete_if{|k,v| v.nil?}
  body["_key"] = @key if body["_key"].nil? && !key.nil?
  request = @@request.merge({ :body => @body.to_json, :query => query })
  result = self.class.post("/_db/#{@database}/_api/document/#{@collection}", request)
  return_result result: result, body: @body
end

#create_edge(body: {}, from:, to:, waitForSync: nil, returnNew: nil, database: @database, collection: @collection) ⇒ Object

TESTED



175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
 
# File 'lib/ArangoRB_Doc.rb', line 175

def create_edge(body: {}, from:, to:, waitForSync: nil, returnNew: nil, database: @database, collection: @collection)  # TESTED
  body = @body.merge(body)
  edges = []
  from = [from] unless from.is_a? Array
  to = [to] unless to.is_a? Array
  from.each do |f|
    body["_from"] = f.is_a?(String) ? f : f.id
    to.each do |t|
      body["_to"] = t.is_a?(String) ? t : t.id
      edges << body.clone
    end
  end
  edges = edges[0]
  ArangoDocument.create(body: edges, waitForSync: waitForSync, returnNew: returnNew, database: database, collection: collection)
end

#create_vertex ⇒ Object

POST ====



150
151
152
153
154
155
156
157
 
# File 'lib/ArangoRB_Doc.rb', line 150

def create(body: {}, waitForSync: nil, returnNew: nil)  # TESTED
  body = @body.merge(body)
  query = {"waitForSync" => waitForSync, "returnNew" => returnNew}.delete_if{|k,v| v.nil?}
  body["_key"] = @key if body["_key"].nil? && !key.nil?
  request = @@request.merge({ :body => @body.to_json, :query => query })
  result = self.class.post("/_db/#{@database}/_api/document/#{@collection}", request)
  return_result result: result, body: @body
end

#database ⇒ Object 



82
83
84
 
# File 'lib/ArangoRB_Doc.rb', line 82

def database
  ArangoDatabase.new(database: @database)
end

#destroy(body: nil, waitForSync: nil, ignoreRevs: nil, returnOld: nil) ⇒ Object

DELETE ===



276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
 
# File 'lib/ArangoRB_Doc.rb', line 276

def destroy(body: nil, waitForSync: nil, ignoreRevs: nil, returnOld: nil)  # TESTED
  query = {
    "waitForSync" => waitForSync,
    "returnOld" => returnOld,
    "ignoreRevs" => ignoreRevs
  }.delete_if{|k,v| v.nil?}
  request = @@request.merge({ :body => body.to_json, :query => query })

  unless body.is_a? Array
    result = self.class.delete("/_db/#{@database}/_api/document/#{@id}", request)
    return_result result: result, caseTrue: true
  else
    result = self.class.delete("/_db/#{@database}/_api/document/#{@collection}", request)
    return_result result: result, caseTrue: true
  end
end

#from ⇒ Object

TESTED



116
117
118
119
120
121
122
123
 
# File 'lib/ArangoRB_Doc.rb', line 116

def from  # TESTED
  result = self.class.get("/_db/#{@database}/_api/document/#{self.body["_from"]}", @@request)
  collection = result["_id"].split("/")[0]
  return result.headers["x-arango-async-id"] if @@async == "store"
  return true if @@async
  result = result.parsed_response
  @@verbose ? result : result["error"] ? result["errorMessage"] : ArangoDocument.new(key: result["_key"], collection: collection, database: @database, body: result)
end

#in(edgeCollection) ⇒ Object

TESTED



104
105
106
 
# File 'lib/ArangoRB_Doc.rb', line 104

def in(edgeCollection)  # TESTED
  self.retrieve_edges collection: edgeCollection, direction: "in"
end

#out(edgeCollection) ⇒ Object

TESTED



108
109
110
 
# File 'lib/ArangoRB_Doc.rb', line 108

def out(edgeCollection)  # TESTED
  self.retrieve_edges collection: edgeCollection, direction: "out"
end

#replace(body: {}, waitForSync: nil, ignoreRevs: nil, returnOld: nil, returnNew: nil) ⇒ Object

MODIFY ===



212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
 
# File 'lib/ArangoRB_Doc.rb', line 212

def replace(body: {}, waitForSync: nil, ignoreRevs: nil, returnOld: nil, returnNew: nil) # TESTED
  query = {
    "waitForSync" => waitForSync,
    "returnNew" => returnNew,
    "returnOld" => returnOld,
    "ignoreRevs" => ignoreRevs
  }.delete_if{|k,v| v.nil?}
  request = @@request.merge({ :body => body.to_json, :query => query })

  unless body.is_a? Array
    result = self.class.put("/_db/#{@database}/_api/document/#{@id}", request)
    self.return_result result: result, body: body
  else
    result = self.class.put("/_db/#{@database}/_api/document/#{@collection}", request)
    i = -1
    return result.headers["x-arango-async-id"] if @@async == "store"
    return true if @@async
    result = result.parsed_response
    @@verbose ? result : !result.is_a?(Array) ? result["errorMessage"] : result.map{|x| ArangoDocument.new(key: x["_key"], collection: @collection, database: @database, body: body[i+=1])}
  end
end

#retrieve ⇒ Object

GET ===



88
89
90
91
 
# File 'lib/ArangoRB_Doc.rb', line 88

def retrieve  # TESTED
  result = self.class.get("/_db/#{@database}/_api/document/#{@id}", @@request)
  self.return_result result: result
end

#retrieve_edges(collection:, direction: nil) ⇒ Object

TESTED



93
94
95
96
97
98
99
100
101
102
 
# File 'lib/ArangoRB_Doc.rb', line 93

def retrieve_edges(collection: , direction: nil)  # TESTED
  query = {"vertex" => @id, "direction" => direction }.delete_if{|k,v| v.nil?}
  request = @@request.merge({ :query => query })
  collection = collection.is_a?(String) ? collection : collection.collection
  result = self.class.get("/_db/#{@database}/_api/edges/#{collection}", request)
  return result.headers["x-arango-async-id"] if @@async == "store"
  return true if @@async
  result = result.parsed_response
  @@verbose ? result : result["error"] ? result["errorMessage"] : result["edges"].map{|edge| ArangoDocument.new(key: edge["_key"], collection: collection, database: @database, body: edge)}
end

#return_result(result:, body: {}, caseTrue: false, key: nil) ⇒ Object

UTILITY ===



295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
 
# File 'lib/ArangoRB_Doc.rb', line 295

def return_result(result:, body: {}, caseTrue: false, key: nil)
  return  result.headers["x-arango-async-id"] if @@async == "store"
  return true if @@async
  result = result.parsed_response
  if @@verbose || !result.is_a?(Hash)
    resultTemp = result
    unless result["errorMessage"]
      result.delete_if{|k,v| k == "error" || k == "code"}
      @key = result["_key"]
      @collection = result["_id"].split("/")[0]
      @body = result.merge(body)
    end
    return resultTemp
  else
    return result["errorMessage"] if result["error"]
    return true if caseTrue
    result.delete_if{|k,v| k == "error" || k == "code"}
    @key = result["_key"]
    @collection = result["_id"].split("/")[0]
    @id = "#{@collection}/#{@key}"
    @body = result.merge(body)
    key.nil? ? self : result[key]
  end
end

#to ⇒ Object

TESTED



125
126
127
128
129
130
131
132
 
# File 'lib/ArangoRB_Doc.rb', line 125

def to  # TESTED
  result = self.class.get("/_db/#{@database}/_api/document/#{self.body["_to"]}", @@request)
  collection = result["_id"].split("/")[0]
  return result.headers["x-arango-async-id"] if @@async == "store"
  return true if @@async
  result = result.parsed_response
  @@verbose ? result : result["error"] ? result["errorMessage"] : ArangoDocument.new(key: result["_key"], collection: collection, database: @database, body: result)
end

#to_hash ⇒ Object Also known as: to_h

RETRIEVE ===



66
67
68
69
70
71
72
73
74
75
 
# File 'lib/ArangoRB_Doc.rb', line 66

def to_hash
  {
    "key" => @key,
    "id" => @id,
    "collection" => @collection,
    "database" => @database,
    "body" => @body,
    "idCache" => @idCache
  }.delete_if{|k,v| v.nil?}
end

#update(body: {}, waitForSync: nil, ignoreRevs: nil, returnOld: nil, returnNew: nil, keepNull: nil, mergeObjects: nil) ⇒ Object

TESTED



234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
 
# File 'lib/ArangoRB_Doc.rb', line 234

def update(body: {}, waitForSync: nil, ignoreRevs: nil, returnOld: nil, returnNew: nil, keepNull: nil, mergeObjects: nil)  # TESTED
  query = {
    "waitForSync" => waitForSync,
    "returnNew" => returnNew,
    "returnOld" => returnOld,
    "ignoreRevs" => ignoreRevs,
    "keepNull" => keepNull,
    "mergeObjects" => mergeObjects
  }.delete_if{|k,v| v.nil?}
  request = @@request.merge({ :body => body.to_json, :query => query })

  unless body.is_a? Array
    result = self.class.patch("/_db/#{@database}/_api/document/#{@id}", request)
    return result.headers["x-arango-async-id"] if @@async == "store"
    return true if @@async
    result = result.parsed_response
    if @@verbose
      unless result["error"]
        @key = result["_key"]
        @id = "#{@collection}/#{@key}"
        @body = body
      end
      result
    else
      return result["errorMessage"] if result["error"]
      @key = result["_key"]
      @id = "#{@collection}/#{@key}"
      @body = @body.merge(body)
      return self
    end
  else
    result = self.class.patch("/_db/#{@database}/_api/document/#{@collection}", request)
    i = -1
    return result.headers["x-arango-async-id"] if @@async == "store"
    return true if @@async
    result = result.parsed_response
    @@verbose ? result : !result.is_a?(Array) ? result["errorMessage"] : result.map{|x| ArangoDocument.new(key: x["_key"], collection: @collection, database: @database, body: body[i+=1])}
  end
end