arangorb 0.1.0

data/lib/ArangoRB_DB.rb

@@ -0,0 +1,170 @@
+# === DATABASE ===
+
+class ArangoDB < ArangoS
+  def initialize(database: @@database)
+    if database.is_a?(String)
+      @database = database
+    else
+      raise "database should be a String, not a #{database.class}"
+    end
+  end
+
+  attr_reader :database
+
+  # === GET ===
+
+  def self.info
+    result = get("/_api/database/current")
+    @@verbose ? result : result["error"] ? result["errorMessage"] : result["result"]
+  end
+
+  # === POST ===
+
+  def create(username: nil, passwd: nil, users: nil)
+    body = {
+      "name" => @database,
+      "username" => username,
+      "passwd" => passwd,
+      "users" => users
+    }
+    body = body.delete_if{|k,v| v.nil?}.to_json
+    new_DB = { :body => body }
+    result = self.class.post("/_api/database", new_DB)
+    @@verbose ? result : result["error"] ? result["errorMessage"] : ArangoDB.new(database: @database)
+  end
+
+  # === DELETE ===
+
+  def destroy
+    result = self.class.delete("/_api/database/#{@database}")
+    @@verbose ? result : result["error"] ? result["errorMessage"] : result["result"]
+  end
+
+  # === LISTS ===
+
+  def self.databases(user: nil)
+    result = user.nil? ? get("/_api/database") : get("/_api/database/#{user}")
+    @@verbose ? result : result["error"] ? result["errorMessage"] : result["result"].map{|x| ArangoDB.new(database: x)}
+  end
+
+  def collections(excludeSystem: true)
+    query = { "excludeSystem": excludeSystem }.delete_if{|k,v| v.nil?}
+    new_Document = { :query => query }
+    result = self.class.get("/_db/#{@database}/_api/collection", new_Document)
+    if @@verbose
+      return result
+    else
+      if result["error"]
+        return result["errorMessage"]
+      else
+        return result["result"].map{|x| ArangoC.new(database: @database, collection: x["name"])}
+      end
+    end
+  end
+
+  def graphs
+    result = self.class.get("/_db/#{@database}/_api/gharial")
+    if @@verbose
+      return result
+    else
+      if result["error"]
+        return result["errorMessage"]
+      else
+        return result["graphs"].map{|x| ArangoG.new(database: @database, graph: x["_key"], edgeDefinitions: x["edgeDefinitions"], orphanCollections: x["orphanCollections"])}
+      end
+    end
+  end
+
+  def functions
+    self.class.get("/_db/#{@database}/_api/aqlfunction").parsed_response
+  end
+
+  # === QUERY ===
+
+  def propertiesQuery
+    result = self.class.get("/_db/#{@database}/_api/query/properties").parsed_response
+    return_result(result)
+  end
+
+  def currentQuery
+    self.class.get("/_db/#{@database}/_api/query/current").parsed_response
+  end
+
+  def slowQuery
+    self.class.get("/_db/#{@database}/_api/query/slow").parsed_response
+  end
+
+  def stopSlowQuery
+    result = self.class.delete("/_db/#{@database}/_api/query/slow").parsed_response
+    @@verbose ? result : result["error"] ? result["errorMessage"] : true
+  end
+
+  def killQuery(id:)
+    result = self.class.delete("/_db/#{@database}/_api/query/#{id}").parsed_response
+    @@verbose ? result : result["error"] ? result["errorMessage"] : true
+  end
+
+  def changePropertiesQuery(slowQueryThreshold: nil, enabled: nil, maxSlowQueries: nil, trackSlowQueries: nil, maxQueryStringLength: nil)
+    body = {
+      "slowQueryThreshold" => slowQueryThreshold,
+      "enabled" => enabled,
+      "maxSlowQueries" => maxSlowQueries,
+      "trackSlowQueries" => trackSlowQueries,
+      "maxQueryStringLength" => maxQueryStringLength
+    }.delete_if{|k,v| v.nil?}
+    new_Document = { :body => body.to_json }
+    result = self.class.put("/_db/#{@database}/_api/query/properties", new_Document).parsed_response
+    return_result(result)
+  end
+
+# === CACHE ===
+
+  def clearCache
+    result = self.class.delete("/_db/#{@database}/_api/query-cache").parsed_response
+    @@verbose ? result : result["error"] ? result["errorMessage"] : true
+  end
+
+  def propertyCache
+    self.class.get("/_db/#{@database}/_api/query-cache/properties").parsed_response
+  end
+
+  def changePropertyCache(mode: nil, maxResults: nil)
+    body = { "mode" => mode, "maxResults" => maxResults }.delete_if{|k,v| v.nil?}
+    new_Document = { :body => body.to_json }
+    self.class.put("/_db/#{@database}/_api/query-cache/properties", new_Document).parsed_response
+  end
+
+  # === AQL FUNCTION ===
+
+  def createFunction(code:, name:, isDeterministic: nil)
+    body = {
+      "code" => code,
+      "name" => name,
+      "isDeterministic" => isDeterministic
+    }.delete_if{|k,v| v.nil?}
+    new_Document = { :body => body.to_json }
+    result = self.class.post("/_db/#{@database}/_api/aqlfunction", new_Document).parsed_response
+    return_result(result)
+  end
+
+  def deleteFunction(name:)
+    result = self.class.delete("/_db/#{@database}/_api/aqlfunction/#{name}")
+    @@verbose ? result : result["error"] ? result["errorMessage"] : true
+  end
+
+  # === UTILITY ===
+
+  def return_result(result)
+    if @@verbose
+      result
+    else
+      if result["error"]
+        result["errorMessage"]
+      else
+        result.delete("error")
+        result.delete("code")
+        result
+      end
+    end
+  end
+end

data/lib/ArangoRB_Doc.rb

@@ -0,0 +1,297 @@
+# ==== DOCUMENT ====
+
+class ArangoDoc < ArangoS
+  def initialize(key: nil, collection: @@collection, database: @@database, body: {}, from: nil, to: nil)
+    if collection.is_a?(String)
+      @collection = collection
+    elsif collection.is_a?(ArangoC)
+      @collection = collection.collection
+    else
+      raise "collection should be a String or an ArangoC instance, not a #{collection.class}"
+    end
+
+    if database.is_a?(String)
+      @database = database
+    else
+      raise "database should be a String, not a #{database.class}"
+    end
+
+    if key.is_a?(String) || key.nil?
+      @key = key
+      unless key.nil?
+        body["_key"] = @key
+        @id = "#{@collection}/#{@key}"
+      end
+    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?(ArangoDoc)
+      @body["_from"] = from.id
+    elsif from.nil?
+    else
+      raise "from should be a String or an ArangoDoc instance, not a #{from.class}"
+    end
+
+    if to.is_a?(String)
+      @body["_to"] = to
+    elsif to.is_a?(ArangoDoc)
+      @body["_to"] = to.id
+    elsif to.nil?
+    else
+      raise "to should be a String or an ArangoDoc instance, not a #{to.class}"
+    end
+  end
+
+  attr_reader :key, :id, :body, :collection, :database
+
+  # === GET ===
+
+  def retrieve
+    result = self.class.get("/_db/#{@database}/_api/document/#{@id}").parsed_response
+    if @@verbose
+      @body = result unless result["error"]
+      result
+    else
+      if result["error"]
+        result["errorMessage"]
+      else
+        @body = result
+        self
+      end
+    end
+  end
+
+  def retrieve_edges(collection: , direction: nil)
+    query = {"vertex" => @id, "direction" => direction }.delete_if{|k,v| v.nil?}
+    new_Document = { :query => query }
+    collection = collection.is_a?(String) ? collection : collection.collection
+    result = self.class.get("/_db/#{@database}/_api/edges/#{collection}", new_Document).parsed_response
+    @@verbose ? result : result["error"] ? result["errorMessage"] : result["edges"].map{|edge|
+      ArangoDoc.new(key: edge["_key"], collection: collection, database: @database, body: edge)
+    }
+  end
+
+  def in(collection)
+    self.retrieve_edges collection: collection, direction: "in"
+  end
+
+  def out(collection)
+    self.retrieve_edges collection: collection, direction: "out"
+  end
+
+  def any(collection)
+    self.retrieve_edges collection: collection
+  end
+
+  def from
+    result = self.class.get("/_db/#{@database}/_api/document/#{self.body["_from"]}").parsed_response
+    collection = result["_id"].split("/")[0]
+    @@verbose ? result : result["error"] ? result["errorMessage"] : ArangoDoc.new(key: result["_key"], collection: collection, database: @database, body: result)
+  end
+
+  def to
+    result = self.class.get("/_db/#{@database}/_api/document/#{self.body["_to"]}").parsed_response
+    collection = result["_id"].split("/")[0]
+    @@verbose ? result : result["error"] ? result["errorMessage"] : ArangoDoc.new(key: result["_key"], collection: collection, database: @database, body: result)
+  end
+
+  # def header
+  #   result = self.class.head("/_db/#{@database}/_api/document/#{@id}", follow_redirects: true, maintain_method_across_redirects: true)
+  #   @@verbose ? result : result["error"] ? result["errorMessage"] : result
+  # end
+
+# === POST ====
+
+  def create(body: @body, waitForSync: nil, returnNew: nil, database: @database, collection: @collection)
+    query = {"waitForSync" => waitForSync, "returnNew" => returnNew}.delete_if{|k,v| v.nil?}
+    unless body.is_a? Array
+      body["_key"] = @key if body["_key"].nil? && !@key.nil?
+      new_Document = { :body => body.to_json, :query => query }
+      result = self.class.post("/_db/#{database}/_api/document/#{collection}", new_Document).parsed_response
+      return_result(result, body)
+    else
+      new_Document = { :body => body.to_json, :query => query }
+      result = self.class.post("/_db/#{database}/_api/document/#{collection}", new_Document).parsed_response
+      i = -1
+      return @@verbose ? result : !result.is_a?(Array) ? result["errorMessage"] : result.map{|x| ArangoDoc.new(key: x["_key"], collection: collection, database: database, body: body[i+=1])}
+    end
+  end
+  alias create_document create
+  alias create_vertex create
+
+  def self.create(body: {}, waitForSync: nil, returnNew: nil, database: @@database, collection: @@collection)
+    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
+      body["_key"] = @key if body["_key"].nil? && !@key.nil?
+      new_Document = { :body => body.to_json, :query => query }
+      result = post("/_db/#{database}/_api/document/#{collection}", new_Document).parsed_response
+      self.return_result(result, body)
+    else
+      new_Document = { :body => body.to_json, :query => query }
+      result = post("/_db/#{database}/_api/document/#{collection}", new_Document).parsed_response
+      i = -1
+      return @@verbose ? result : !result.is_a?(Array) ? result["errorMessage"] : result.map{|x| ArangoDoc.new(key: x["_key"], collection: collection, database: database, body: body[i+=1])}
+    end
+  end
+
+  def create_edge(body: [{}], from:, to:, waitForSync: nil, returnNew: nil, database: @database, collection: @collection)
+    edges = []
+    from = [from] unless from.is_a? Array
+    to = [to] unless to.is_a? Array
+    body = [body] unless body.is_a? Array
+    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
+    create(body: edges, waitForSync: waitForSync, returnNew: returnNew, database: database, collection: collection)
+    # ArangoDoc.create_edge(body: body, from: from, to: to, waitForSync: waitForSync, returnNew: returnNew, database: database, collection: collection)
+  end
+
+  def self.create_edge(body: {}, from:, to:, waitForSync: nil, returnNew: nil, database: @@database, collection: @@collection)
+    edges = []
+    from = [from] unless from.is_a? Array
+    to = [to] unless to.is_a? Array
+    body = [body] unless body.is_a? Array
+    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
+    self.create(body: edges, waitForSync: waitForSync, returnNew: returnNew, database: database, collection: collection)
+  end
+
+# === MODIFY ===
+
+  def replace(body: {}, waitForSync: nil, ignoreRevs: nil, returnOld: nil, returnNew: nil)
+    query = {
+      "waitForSync" => waitForSync,
+      "returnNew" => returnNew,
+      "returnOld" => returnOld,
+      "ignoreRevs" => ignoreRevs
+    }.delete_if{|k,v| v.nil?}
+    new_Document = { :body => body.to_json, :query => query }
+
+    unless body.is_a? Array
+      result = self.class.put("/_db/#{@database}/_api/document/#{@id}", new_Document).parsed_response
+      return_result(result, body)
+    else
+      result = self.class.put("/_db/#{@database}/_api/document/#{@collection}", new_Document).parsed_response
+      i = -1
+      return @@verbose ? result : !result.is_a?(Array) ? result["errorMessage"] : result.map{|x| ArangoDoc.new(key: x["_key"], collection: @collection, database: @database, body: body[i+=1])}
+    end
+  end
+
+  def update(body: {}, waitForSync: nil, ignoreRevs: nil, returnOld: nil, returnNew: nil, keepNull: nil, mergeObjects: nil)
+    query = {
+      "waitForSync" => waitForSync,
+      "returnNew" => returnNew,
+      "returnOld" => returnOld,
+      "ignoreRevs" => ignoreRevs,
+      "keepNull" => keepNull,
+      "mergeObjects" => mergeObjects
+    }.delete_if{|k,v| v.nil?}
+    new_Document = { :body => body.to_json, :query => query }
+
+    unless body.is_a? Array
+      result = self.class.patch("/_db/#{@database}/_api/document/#{@id}", new_Document).parsed_response
+      if @@verbose
+        unless result["error"]
+          @key = result["_key"]
+          @id = "#{@collection}/#{@key}"
+          @body = body
+        end
+        result
+      else
+        if result["error"]
+          result["errorMessage"]
+        else
+          @key = result["_key"]
+          @id = "#{@collection}/#{@key}"
+          @body = @body.merge(body)
+          self
+        end
+      end
+    else
+      result = self.class.patch("/_db/#{@database}/_api/document/#{@collection}", new_Document).parsed_response
+      i = -1
+      return @@verbose ? result : !result.is_a?(Array) ? result["errorMessage"] : result.map{|x| ArangoDoc.new(key: x["_key"], collection: @collection, database: @database, body: body[i+=1])}
+    end
+  end
+
+# === DELETE ===
+
+  def destroy(body: nil, waitForSync: nil, ignoreRevs: nil, returnOld: nil)
+    query = {
+      "waitForSync" => waitForSync,
+      "returnOld" => returnOld,
+      "ignoreRevs" => ignoreRevs
+    }.delete_if{|k,v| v.nil?}
+    new_Document = { :query => query }
+
+    unless body.is_a? Array
+      result = self.class.delete("/_db/#{@database}/_api/document/#{@id}", new_Document).parsed_response
+      @@verbose ? result : result["error"] ? result["errorMessage"] : true
+    else
+      new_Document = { :body => body.to_json, :query => query }
+      result = self.class.delete("/_db/#{@database}/_api/document/#{@collection}", new_Document).parsed_response
+      return result
+    end
+  end
+
+# === UTILITY ===
+
+  def return_result(result, body)
+    if @@verbose
+      unless result["error"]
+        @key = result["_key"]
+        @id = "#{@collection}/#{@key}"
+        @body = body
+      end
+      result
+    else
+      if result["error"]
+        result["errorMessage"]
+      else
+        @key = result["_key"]
+        @id = "#{@collection}/#{@key}"
+        @body = body
+        self
+      end
+    end
+  end
+
+  def self.return_result(result, body)
+    if @@verbose
+      result
+    else
+      if result["error"]
+        result["errorMessage"]
+      else
+        ArangoDoc.new key: result["_key"], collection: result["_id"].split("/")[0], body: body
+      end
+    end
+  end
+end