arangorb3 0.0.10

data/lib/Document.rb

@@ -0,0 +1,346 @@
+# ==== DOCUMENT ====
+
+module Arango
+  class Document
+    include Arango::Helper_Error
+    include Arango::Helper_Return
+    include Arango::Collection_Return
+
+    def self.new(*args)
+      hash = args[0]
+      super unless hash.is_a?(Hash)
+      collection = hash[:collection]
+      if collection.is_a?(Arango::Collection) &&
+        collection.database.server.active_cache && !hash[:name].nil?
+        cache_name = "#{collection.database.name}/#{collection.name}/#{hash[:name]}"
+        cached = collection.database.server.cache.cache.dig(:document, cache_name)
+        if cached.nil?
+          hash[:cache_name] = cache_name
+          return super
+        else
+          body = hash[:body] || {}
+          [:rev, :from, :to].each{|k| body[:"_#{k}"] ||= hash[k]}
+          body[:"_key"] ||= hash[:name]
+          cached.assign_attributes(body)
+          return cached
+        end
+      end
+      super
+    end
+
+    def initialize(name: nil, collection:, body: {}, rev: nil, from: nil,
+      to: nil, cache_name: nil)
+      assign_collection(collection)
+      unless cache_name.nil?
+        @cache_name = cache_name
+        @server.cache.save(:document, cache_name, self)
+      end
+      body[:_key]  ||= name
+      body[:_rev]  ||= rev
+      body[:_to]   ||= to
+      body[:_from] ||= from
+      body[:_id]   ||= "#{@collection.name}/#{name}" unless name.nil?
+      assign_attributes(body)
+    end
+
+    def name
+      return @body[:_key]
+    end
+    alias key name
+
+    def rev
+      return @body[:_rev]
+    end
+
+    def id
+      return @body[:_id]
+    end
+
+    def name=(att)
+      assign_attributes({_key: att})
+    end
+    alias key= name=
+
+    def rev=(att)
+      assign_attributes({_rev: att})
+    end
+
+    def id=(att)
+      assign_attributes({_id: id})
+    end
+
+    def from=(att)
+      att = att.id if att.is_a?(Arango::Document)
+      assign_attributes({_from: att})
+    end
+
+    def to=(att)
+      att = att.id if att.is_a?(Arango::Document)
+      assign_attributes({_to: att})
+    end
+
+# === DEFINE ==
+
+    attr_reader :collection, :graph, :database, :server, :body, :cache_name
+
+    def body=(result)
+      result.delete_if{|k,v| v.nil?}
+      @body ||= {}
+      # binding.pry if @body[:_key] == "Second_Key"
+      hash = {
+        "_key":  @body[:_key],
+        "_id":   @body[:_id],
+        "_rev":  @body[:_rev],
+        "_from": @body[:_from],
+        "_to":   @body[:_to]
+      }
+      @body = hash.merge(result)
+      if @body[:_id].nil? && !@body[:_key].nil?
+        @body[:_id] = "#{@collection.name}/#{@body[:_key]}"
+      end
+      set_up_from_or_to("from", result[:_from])
+      set_up_from_or_to("to", result[:_to])
+      if @server.active_cache && @cache_name.nil? && !@body[:_id].nil?
+        @cache_name = "#{@database.name}/#{@body[:_id]}"
+        @server.cache.save(:document, @cache_name, self)
+      end
+    end
+    alias assign_attributes body=
+
+# === TO HASH ===
+
+    def to_h
+      {
+        "name":  @body[:_key],
+        "id":    @body[:_id],
+        "rev":   @body[:_rev],
+        "from":  @body[:_from],
+        "to":    @body[:_to],
+        "body":  @body,
+        "cache_name":  @cache_name,
+        "collection": @collection.name,
+        "graph": @graph&.name
+      }.delete_if{|k,v| v.nil?}
+    end
+
+    def set_up_from_or_to(attrs, var)
+      case var
+      when NilClass
+        @body[:"_#{attrs}"] = nil
+      when String
+        unless var.include?("/")
+          raise Arango::Error.new err: :attribute_is_not_valid, data:
+            {"attribute": attrs, "wrong_value": var}
+        end
+        @body[:"_#{attrs}"] = var
+      when Arango::Document
+        @body[:"_#{attrs}"] = var.id
+        @from = var if attrs == "from"
+        @to   = var if attrs == "to"
+      else
+        raise Arango::Error.new err: :attribute_is_not_valid, data:
+          {"attribute": attrs, "wrong_value": var}
+      end
+    end
+    private :set_up_from_or_to
+
+    def from(string: false)
+      return @body[:_from] if string
+      @from ||= retrieve_instance_from_and_to(@body[:_from])
+      return @from
+    end
+
+    def to(string: false)
+      return @body[:_to] if string
+      @to ||= retrieve_instance_from_and_to(@body[:_to])
+      return @to
+    end
+
+    def retrieve_instance_from_and_to(var)
+      case var
+      when NilClass
+        return nil
+      when String
+        collection_name, document_name = var.split("/")
+        collection = Arango::Collection.new name: collection_name, database: @database
+        if @graph.nil?
+          return Arango::Document.new(name: document_name, collection: collection)
+        else
+          collection.graph = @graph
+          return Arango::Vertex.new(name: document_name, collection: collection)
+        end
+      end
+    end
+    private :retrieve_instance_from_and_to
+
+# == GET ==
+
+    def retrieve(if_none_match: false, if_match: false)
+      headers = {}
+      headers[:"If-None-Match"] = @body[:_rev] if if_none_match
+      headers[:"If-Match"]      = @body[:_rev] if if_match
+      result = @database.request("GET",  "_api/document/#{@body[:_id]}", headers: headers)
+      return_element(result)
+    end
+
+# == HEAD ==
+
+    def head(if_none_match: false, if_match: false)
+      headers = {}
+      headers[:"If-None-Match"] = @body[:_rev] if if_none_match
+      headers[:"If-Match"]      = @body[:_rev] if if_match
+      @database.request("HEAD", "_api/document/#{@body[:_id]}", headers: headers)
+    end
+
+# == POST ==
+
+    def create(body: {}, waitForSync: nil, returnNew: nil, silent: nil)
+      body = @body.merge(body)
+      query = {
+        "waitForSync": waitForSync,
+        "returnNew":   returnNew,
+        "silent":      silent
+      }
+      result = @database.request("POST", "_api/document/#{@collection.name}", body: body,
+        query: query)
+      return result if @server.async != false || silent
+      body2 = result.clone
+      if returnNew
+        body2.delete(:new)
+        body2 = body2.merge(result[:new])
+      end
+      body = body.merge(body2)
+      assign_attributes(body)
+      return return_directly?(result) ? result : self
+    end
+
+# == PUT ==
+
+    def replace(body: {}, waitForSync: nil, ignoreRevs: nil, returnOld: nil,
+      returnNew: nil, silent: nil, if_match: false)
+      query = {
+        "waitForSync": waitForSync,
+        "returnNew":   returnNew,
+        "returnOld":   returnOld,
+        "ignoreRevs":  ignoreRevs,
+        "silent":      silent
+      }
+      headers = {}
+      headers[:"If-Match"] = @body[:_rev] if if_match
+      result = @database.request("PUT", "_api/document/#{@body[:_id]}", body: body,
+        query: query, headers: headers)
+      return result if @server.async != false || silent
+      body2 = result.clone
+      if returnNew
+        body2.delete(:new)
+        body2 = body2.merge(result[:new])
+      end
+      body = body.merge(body2)
+      assign_attributes(body)
+      return return_directly?(result) ? result : self
+    end
+
+    def update(body: {}, waitForSync: nil, ignoreRevs: nil,
+      returnOld: nil, returnNew: nil, keepNull: nil,
+      mergeObjects: nil, silent: nil, if_match: false)
+      query = {
+        "waitForSync":  waitForSync,
+        "returnNew":    returnNew,
+        "returnOld":    returnOld,
+        "ignoreRevs":   ignoreRevs,
+        "keepNull":     keepNull,
+        "mergeObjects": mergeObjects,
+        "silent":       silent
+      }
+      headers = {}
+      headers[:"If-Match"] = @body[:_rev] if if_match
+      result = @database.request("PATCH", "_api/document/#{@body[:_id]}", body: body,
+        query: query, headers: headers, keepNull: keepNull)
+      return result if @server.async != false || silent
+      body2 = result.clone
+      if returnNew
+        body2.delete(:new)
+        body2 = body2.merge(result[:new])
+      end
+      body = body.merge(body2)
+      if mergeObjects
+        @body = @body.merge(body)
+      else
+        body.each{|key, value| @body[key] = value}
+      end
+      assign_attributes(@body)
+      return return_directly?(result) ? result : self
+    end
+
+  # === DELETE ===
+
+    def destroy(waitForSync: nil, silent: nil, returnOld: nil, if_match: false)
+      query = {
+        "waitForSync": waitForSync,
+        "returnOld":   returnOld,
+        "silent":      silent
+      }
+      headers = {}
+      headers[:"If-Match"] = @body[:_rev] if if_match
+      result = @database.request("DELETE", "_api/document/#{@body[:_id]}", query: query,
+        headers: headers)
+      return result if @server.async != false || silent
+      body2 = result.clone
+      if returnOld
+        body2.delete(:old)
+        body2 = body2.merge(result[:old])
+      else
+        body2 = body2.merge(@body)
+      end
+      return_element(body2)
+      return true
+    end
+
+  # === EDGE ===
+
+    def edges(collection:, direction: nil)
+      satisfy_class?(collection, [Arango::Collection, String])
+      collection = collection.is_a?(Arango::Collection) ? collection.name : collection
+      query = {
+        "vertex":    @body[:_id],
+        "direction": direction
+      }
+      result = @database.request("GET", "_api/edges/#{collection}", query: query)
+      return result if return_directly?(result)
+      result[:edges].map do |edge|
+        collection_name, key = edge[:_id].split("/")
+        collection = Arango::Collection.new(name: collection_name,
+          database: @database, type: :edge)
+        Arango::Document.new(name: key, body: edge, collection: collection)
+      end
+    end
+
+    def any(collection)
+      edges(collection: collection)
+    end
+
+    def out(collection)
+      edges(collection: collection, direction: "out")
+    end
+
+    def in(collection)
+      edges(collection: collection, direction: "in")
+    end
+
+# === TRAVERSAL ===
+
+    def traversal(body: {}, sort: nil, direction: nil, minDepth: nil,
+      visitor: nil, itemOrder: nil, strategy: nil,
+      filter: nil, init: nil, maxIterations: nil, maxDepth: nil,
+      uniqueness: nil, order: nil, expander: nil,
+      edgeCollection: nil)
+      Arango::Traversal.new(body: body,
+        sort: sort, direction: direction, minDepth: minDepth,
+        vertex: self, visitor: visitor,itemOrder: itemOrder,
+        strategy: strategy, filter: filter, init: init,
+        maxIterations: maxIterations, maxDepth: maxDepth,
+        uniqueness: uniqueness, order: order,
+        expander: expander, edgeCollection: edgeCollection)
+    end
+  end
+end

data/lib/Edge.rb

@@ -0,0 +1,104 @@
+# === GRAPH VERTEX ===
+
+module Arango
+  class Edge < Arango::Document
+    def initialize(name: nil, collection:, body: {}, rev: nil, from: nil,
+      to: nil)
+      assign_collection(collection)
+      body[:_key]  ||= name
+      body[:_rev]  ||= rev
+      body[:_from] ||= from
+      body[:_to]   ||= to
+      body[:_id]   ||= "#{@collection.name}/#{name}" unless name.nil?
+      assign_attributes(body)
+    end
+
+# === DEFINE ===
+
+    attr_reader :collection, :database, :server, :graph
+
+    def collection=(collection)
+      satisfy_class?(collection, [Arango::Collection])
+      if collection.graph.nil?
+        raise Arango::Error.new err: :collection_does_not_have_a_graph, data:
+          {"name_collection": collection.name, "graph": nil}
+      end
+      @collection = collection
+      @graph      = @collection.graph
+      @database   = @collection.database
+      @server     = @database.server
+    end
+    alias assign_collection collection=
+
+# == GET ==
+
+    def retrieve(if_match: false)
+      headers = {}
+      headers[:"If-Match"] = @body[:_rev] if if_match
+      result = @graph.request("GET", "edge/#{@collection.name}/#{@body[:_key]}",
+        headers: headers, key: :edge)
+      return_element(result)
+    end
+
+# == POST ==
+
+    def create(body: {}, waitForSync: nil)
+      body = @body.merge(body)
+      query = {
+        "waitForSync": waitForSync,
+        "_from":      @body[:_from],
+        "_to":        @body[:_to]
+      }
+      result = @graph.request("POST", "edge/#{@collection.name}", body: body,
+        query: query, key: :edge)
+      return result if @server.async != false
+      body2 = result.clone
+      body = body.merge(body2)
+      assign_attributes(body)
+      return return_directly?(result) ? result : self
+    end
+
+# == PUT ==
+
+    def replace(body: {}, waitForSync: nil, keepNull: nil, if_match: false)
+      query = {
+        "waitForSync": waitForSync,
+        "keepNull":    keepNull
+      }
+      headers = {}
+      headers[:"If-Match"] = @body[:_rev] if if_match
+      result = @graph.request("PUT", "edge/#{@collection.name}/#{@body[:_key]}",
+        body: body, query: query, headers: headers, key: :edge)
+      return result if @server.async != false
+      body2 = result.clone
+      body = body.merge(body2)
+      assign_attributes(body)
+      return return_directly?(result) ? result : self
+    end
+
+    def update(body: {}, waitForSync: nil, if_match: false)
+      query = {"waitForSync": waitForSync}
+      headers = {}
+      headers[:"If-Match"] = @body[:_rev] if if_match
+      result = @graph.request("PATCH", "edge/#{@collection.name}/#{@body[:_key]}",
+        body: body, query: query, headers: headers, key: :edge)
+      return result if @server.async != false
+      body2 = result.clone
+      body = body.merge(body2)
+      body = @body.merge(body)
+      assign_attributes(body)
+      return return_directly?(result) ? result : self
+    end
+
+# === DELETE ===
+
+    def destroy(waitForSync: nil, if_match: false)
+      query = {"waitForSync": waitForSync}
+      headers = {}
+      headers[:"If-Match"] = @body[:_rev] if if_match
+      result = @graph.request("DELETE", "edge/#{@collection.name}/#{@body[:_key]}",
+        query: query, headers: headers)
+      return_delete(result)
+    end
+  end
+end

data/lib/Error.rb

@@ -0,0 +1,125 @@
+# === ERROR ===
+
+module Arango
+  class Error < StandardError
+    @@list_arango_rb_errors = {
+      no_other_aql_next: {
+        code: 10001, message: "No other values with AQL next"
+      },
+      no_other_simple_next: {
+        code: 10002, message: "No other values with AQL next"
+      },
+      is_a_edge_collection: {
+        code: 10003, message: "This collection is an Edge collection"
+      },
+      is_a_document_collection: {
+        code: 10004, message: "This collection is a Document collection"
+      },
+      database_graph_no_same_as_collection_database: {
+        code: 10005, message: "Database of graph is not the same as the class"
+      },
+      wrong_type_instead_of_expected_one: {
+        code: 10006, message: "Expected a type, received another"
+      },
+      no_other_export_next: {
+        code: 10007, message: "No other values with AQL next"
+      },
+      no_aql_id_available: {
+        code: 10008, message: "AQL does not have id. It could have already been killed"
+      },
+      id_is_not_valid: {
+        code: 10009, message: "Given attribute is not a valid document id or an Arango::Document"
+      },
+      collection_does_not_have_a_graph: {
+        code: 10010, message: "Collection does not have a graph"
+      },
+      arangodb_did_not_return_a_valid_result: {
+        code: 10011, message: "ArangoDB didn't return a valid result"
+      },
+      read_or_write_should_be_string_or_collections: {
+        code: 10012, message: "read or write should be an array of name classes or Arango::Collections"
+      },
+      wrong_class: {
+        code: 10013, message: "Wrong class"
+      },
+      wrong_element: {
+        code: 10014, message: "Element is not part of the list"
+      },
+      orphan_collection_used_by_edge_definition: {
+        code: 10015, message: "Orphan collection is already used by an edge definition"
+      },
+      impossible_to_parse_arangodb_response: {
+        code: 10016, message: "Impossible to parse ArangoDB response"
+      },
+      batch_query_not_valid: {
+        code: 10017, message: "Query is not valid"
+      },
+      arangorb_didnt_return_a_valid_result: {
+        code: 10018, message: "ArangoRB didn't return a valid result"
+      },
+      impossible_to_connect_with_database: {
+        code: 10019, message: "Impossible to connect with database"
+      },
+      you_cannot_assign_from_or_to_to_a_vertex: {
+        code: 10020, message: "You cannot assign from or to to a Vertex"
+      },
+      wrong_start_vertex_type: {
+        code: 10021, message: "Starting vertex should be an Arango::Vertex, an Arango::Document (not Edge) or a valid vertex id"
+      },
+      database_undefined_for_traversal: {
+        code: 10022, message: "Database undefined for traversal"
+      },
+      edge_collection_should_be_of_type_edge: {
+        code: 10022, message: "Database undefined for traversal"
+      }
+    }
+
+    def initialize(err:, data: nil, skip_assignment: false)
+      unless skip_assignment
+        @message = @@list_arango_rb_errors[err][:message]
+        @code = @@list_arango_rb_errors[err][:code]
+        @internal_code = err
+        @data = data
+      end
+      super(@message)
+    end
+    attr_reader :data, :code, :message
+
+    def to_h
+      {
+        "message": @message,
+        "code": @code,
+        "data": @data,
+        "internal_code": @internal_code
+      }.delete_if{|k,v| v.nil?}
+    end
+  end
+end
+
+module Arango
+  class ErrorDB < Arango::Error
+    def initialize(message:, code:, data:, errorNum:, action:, url:, request:)
+      @message  = message
+      @code     = code
+      @data     = data
+      @errorNum = errorNum
+      @action   = action
+      @url      = url
+      @request  = request
+      super(err: nil, skip_assignment: true)
+    end
+    attr_reader :message, :code, :data, :errorNum, :action, :url, :request
+
+    def to_h
+      {
+        "action": @action,
+        "url": @url,
+        "request": @request,
+        "message": @message,
+        "code": @code,
+        "data": @data,
+        "errorNum": @errorNum
+      }.delete_if{|k,v| v.nil?}
+    end
+  end
+end