arango-driver 3.5.0.alpha0

data/lib/arango/edge.rb

@@ -0,0 +1,164 @@
+# === 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, :graph, :server
+
+    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: {}, wait_for_sync: nil)
+      body = @body.merge(body)
+      query = {
+        waitForSync: wait_for_sync,
+        _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: {}, wait_for_sync: nil, keep_null: nil, if_match: false)
+      query = {
+        waitForSync: wait_for_sync,
+        keepNull:    keep_null
+      }
+      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: {}, wait_for_sync: nil, if_match: false)
+      query = {waitForSync: wait_for_sync}
+      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(wait_for_sync: nil, if_match: false)
+      query = {waitForSync: wait_for_sync}
+      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
+
+    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
+
+    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 collection_name, database: @database
+        if @graph.nil?
+          return Arango::Document.new(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
+  end
+end

data/lib/arango/error.rb

@@ -0,0 +1,97 @@
+# === ERROR ===
+
+module Arango
+  class Error < StandardError
+    ARANGODB_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"
+      }
+    }.freeze
+
+    def initialize(err:, data: nil, skip_assignment: false)
+      unless skip_assignment
+        @message = ARANGODB_ERRORS[err][:message]
+        @code = ARANGODB_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

data/lib/arango/error_db.rb

@@ -0,0 +1,27 @@
+module Arango
+  class ErrorDB < Arango::Error
+    def initialize(message:, code:, data:, error_num:, action: nil, url: nil, request:)
+      @message   = message
+      @code      = code
+      @data      = data
+      @error_num = error_num
+      @action    = action
+      @url       = url
+      @request   = request
+      super(err: nil, skip_assignment: true)
+    end
+    attr_reader :action, :code, :data, :error_num, :message, :request, :url
+
+    def to_h
+      {
+        action: @action,
+        url: @url,
+        request: @request,
+        message: @message,
+        code: @code,
+        data: @data,
+        errorNum: @error_num
+      }.delete_if{|k,v| v.nil?}
+    end
+  end
+end

data/lib/arango/foxx.rb

@@ -0,0 +1,255 @@
+# === FOXX ===
+
+module Arango
+  class Foxx
+    include Arango::Helper::Satisfaction
+    include Arango::Helper::Return
+    include Arango::Helper::DatabaseAssignment
+
+    def initialize(database:, body: {}, mount:, development: nil, legacy: nil,
+      provides: nil, name: nil, version: nil, type: "application/json",
+      setup: nil, teardown: nil, cache_name: nil)
+      assign_database(database)
+      unless cache_name.nil?
+        @cache_name = cache_name
+        @server.cache.save(:foxx, cache_name, self)
+      end
+      assign_attributes(body)
+      assign_type(type)
+      @development ||= development
+      @legacy      ||= legacy
+      @mount       ||= mount
+      @name        ||= name
+      @provides    ||= provides
+      @setup       ||= setup
+      @teardown    ||= teardown
+      @version     ||= version
+    end
+
+# === DEFINE ===
+
+    attr_reader :body, :cache_name, :database, :server, :type
+    attr_accessor :development, :legacy, :mount, :name, :provides, :setup, :teardown, :version
+
+    def body=(result)
+      if result.is_a?(Hash)
+        @body        = result
+        @development = result[:development] || @development
+        @legacy      = result[:legacy]      || @legacy
+        @mount       = result[:mount]       || @mount
+        @name        = result[:name]        || @name
+        @provides    = result[:provides]    || @provides
+        @version     = result[:version]     || @version
+        if @server.active_cache && @cache_name.nil?
+          @cache_name = "#{@database.name}/#{@mount}"
+          @server.cache.save(:task, @cache_name, self)
+        end
+      end
+    end
+    alias assign_attributes body=
+
+    def type=(type)
+      satisfy_category?(type, %w[application/zip zip application/javascript javascript application/json json multipart/form-data data])
+      type = "application/#{type}" if %w[zip javascript json].include?(type)
+      type = "multipart/form-data" if type == "data"
+      @type = type
+    end
+    alias assign_type type=
+
+# === TO HASH ===
+
+    def to_h
+      {
+        cache_name: @cache_name,
+        database: @database.name,
+        development: @development,
+        legacy: @legacy,
+        mount: @mount,
+        name: @name,
+        provides: @provides,
+        teardown: @teardown,
+        type: @type,
+        version: @version
+      }.delete_if{|k,v| v.nil?}
+    end
+
+    def return_foxx(result, val=nil)
+      return result if @server.async != false
+      case val
+      when :configuration
+        @configuration = result
+      when :dependencies
+        @dependencies = result
+      else
+        assign_attributes(result)
+      end
+      return return_directly?(result) ? result : self
+    end
+    private :return_foxx
+
+  # === ACTIONS ===
+
+    def retrieve
+      query = {mount: @mount}
+      result = @database.request("GET", url: "_api/foxx/service")
+      return_foxx(result)
+    end
+
+    def create(body: @body, type: @type, development: @development,
+      setup: @setup, legacy: @legacy)
+      headers = { Accept: type }
+      skip_to_json = type != "application/json"
+      query = {
+        mount:        @mount,
+        setup:        setup,
+        development: development,
+        legacy:       legacy
+      }
+      result = @database.request("POST",
+        url: "_api/foxx", body: body, headers: headers,
+        skip_to_json: skip_to_json, query: query)
+      return_foxx(result)
+    end
+
+    def destroy(teardown: @teardown)
+      query = {
+        mount:    @mount,
+        teardown: teardown
+      }
+      result = @database.request("DELETE", "_api/foxx/service", query: query)
+      return_foxx(result)
+    end
+
+    def replace(body: @body, type: @type, teardown: @teardown, setup: @setup,
+      legacy: @legacy)
+      headers = { Accept: type }
+      skip_to_json = type != "application/json"
+      query = {
+        mount:    @mount,
+        setup:    setup,
+        teardown: teardown,
+        legacy:   legacy
+      }
+      result = @database.request("PUT", "_api/foxx/service", body: body,
+        headers: headers, skip_to_json: skip_to_json, query: query)
+      return_foxx(result)
+    end
+
+    def update(body: @body, type: @type, teardown: @teardown,
+      setup: @setup, legacy: @legacy)
+      assign_type(type)
+      headers = { Accept: type }
+      skip_to_json = @type != "application/json"
+      query = {
+        mount:        @mount,
+        setup:        setup,
+        teardown:     teardown,
+        legacy:       legacy
+      }
+      result = @database.request("PATCH", "_api/foxx/service", body: body,
+        headers: headers, skip_to_json: skip_to_json, query: query)
+      return_foxx(result)
+    end
+
+  # === CONFIGURATION ===
+
+    def retrieve_configuration
+      query = { mount: @mount }
+      result = @database.request("GET", "_api/foxx/configuration", query: query)
+      return_foxx(result, :configuration)
+    end
+
+    def update_configuration(body:)
+      query = { mount: @mount }
+      result = @database.request("PATCH", "_api/foxx/configuration", query: query, body: body)
+      return_foxx(result, :configuration)
+    end
+
+    def replace_configuration(body:)
+      query = { mount: @mount }
+      result = @database.request("PUT", "_api/foxx/configuration", query: query, body: body)
+      return_foxx(result, :configuration)
+    end
+
+    # === DEPENDENCY ===
+
+    def retrieve_dependencies
+      query = { mount: @mount }
+      result = @database.request("GET", "_api/foxx/dependencies", query: query)
+      return_foxx(result, :dependencies)
+    end
+
+    def update_dependencies(body:)
+      query = { mount: @mount }
+      result = @database.request("PATCH", "_api/foxx/dependencies", query: query, body: body)
+      return_foxx(result, :dependencies)
+    end
+
+    def replace_dependencies(body:)
+      query = { mount: @mount }
+      result = @database.request("PUT", "_api/foxx/dependencies", query: query, body: body)
+      return_foxx(result, :dependencies)
+    end
+
+    # === MISCELLANEOUS
+
+    def scripts
+      query = { mount: @mount }
+      @database.request("GET", "_api/foxx/scripts", query: query)
+    end
+
+    def run_script(name:, body: {})
+      query = { mount: @mount }
+      @database.request("POST", "_api/foxx/scripts/#{name}", query: query, body: body)
+    end
+
+    def tests(reporter: nil, idiomatic: nil)
+      satisfy_category?(reporter, [nil, "default", "suite", "stream", "xunit", "tap"])
+      headers = {}
+      headers[:"Content-Type"] = case reporter
+      when "stream"
+        "application/x-ldjson"
+      when "tap"
+        "text/plain, text/*"
+      when "xunit"
+        "application/xml, text/xml"
+      else
+        nil
+      end
+      query = { mount: @mount }
+      @database.request("GET", "_api/foxx/scripts", query: query, headers: headers)
+    end
+
+    def enable_development
+      query = { mount: @mount }
+      @database.request("POST", "_api/foxx/development", query: query)
+    end
+
+    def disable_development
+      query = { mount: @mount }
+      @database.request("DELETE", "_api/foxx/development", query: query)
+    end
+
+    def readme
+      query = { mount: @mount }
+      @database.request("GET", "_api/foxx/readme", query: query)
+    end
+
+    def swagger
+      query = { mount: @mount }
+      @database.request("GET", "_api/foxx/swagger", query: query)
+    end
+
+    def download(path:, warning: @server.warning)
+      query = { mount: @mount }
+      @server.download("POST", "_db/#{@database.name}/_api/foxx/download",
+        path: path, query: query)
+      puts "File saved in #{path}" if warning
+    end
+
+    def commit(body:, replace: nil)
+      query = { replace: replace }
+      @database.request("POST", "_api/foxx/commit", body: body, query: query)
+    end
+  end
+end