arango-driver 3.5.0.alpha0

data/lib/arango/collection/documents.rb

@@ -0,0 +1,122 @@
+module Arango
+  class Collection
+    module Documents
+      def new_document(document, wait_for_sync: nil)
+        Arango::Document.new(document, collection: self, wait_for_sync: wait_for_sync)
+      end
+
+      def create_document(document, wait_for_sync: nil)
+        Arango::Document.new(document, collection: self, wait_for_sync: wait_for_sync).create
+      end
+      def batch_create_document(document, wait_for_sync: nil)
+        Arango::Document.new(document, collection: self, wait_for_sync: wait_for_sync).batch_create
+      end
+
+      def create_documents(array_of_property_hashes, wait_for_sync: nil)
+        Arango::Document.create_documents(array_of_property_hashes, collection: self, wait_for_sync: wait_for_sync)
+      end
+      def batch_create_documents(array_of_property_hashes, wait_for_sync: nil)
+        Arango::Document.batch_create_documents(array_of_property_hashes, collection: self, wait_for_sync: wait_for_sync)
+      end
+
+      def exist_document?(*args)
+        Arango::Document.exist?(*args, collection: self)
+      end
+      def batch_exist_document?(*args)
+        Arango::Document.batch_exist?(*args, collection: self)
+      end
+      alias document_exist? exist_document?
+      alias batch_document_exist? batch_exist_document?
+
+      def get_document(key)
+        Arango::Document.get(key, collection: self)
+      end
+      def batch_get_document(key)
+        Arango::Document.batch_get(key, collection: self)
+      end
+      alias fetch_document get_document
+      alias retrieve_document get_document
+      alias batch_fetch_document batch_get_document
+      alias batch_retrieve_document batch_get_document
+
+      def get_documents(keys)
+        Arango::Document.get_documents(keys, collection: self)
+      end
+      def batch_get_documents(name)
+        Arango::Document.batch_get_documents(name: name, collection: self)
+      end
+      alias fetch_documents get_documents
+      alias retrieve_documents get_documents
+      alias batch_fetch_documents batch_get_documents
+      alias batch_retrieve_documents batch_get_documents
+
+      def all_documents(offset: 0, limit: nil, batch_size: nil)
+        return nil if type == :edge
+        Arango::Document.all(offset: offset, limit: limit, batch_size: batch_size, collection: self)
+      end
+      def batch_all_documents(offset: 0, limit: nil, batch_size: nil)
+        return nil if type == :edge
+        Arango::Document.batch_all(offset: offset, limit: limit, batch_size: batch_size, collection: self)
+      end
+
+      def list_documents(offset: 0, limit: nil, batch_size: nil)
+        Arango::Document.list(offset: offset, limit: limit, batch_size: batch_size, collection: self)
+      end
+      def batch_list_documents(offset: 0, limit: nil, batch_size: nil)
+        Arango::Document.batch_list(offset: offset, limit: limit, batch_size: batch_size, collection: self)
+      end
+
+      def replace_document(document)
+        Arango::Document.replace(document)
+      end
+      def batch_replace_document(document)
+        Arango::Document.batch_replace(document)
+      end
+
+      def replace_documents(documents_array, wait_for_sync: nil, ignore_revs: nil, return_old: nil, return_new: nil)
+        Arango::Document.replace_documents(documents_array)
+      end
+      def batch_replace_documents(documents_array, wait_for_sync: nil, ignore_revs: nil, return_old: nil, return_new: nil)
+        Arango::Document.batch_replace_documents(documents_array)
+      end
+
+      def save_document(document)
+        Arango::Document.save(document)
+      end
+      def batch_save_document(document)
+        Arango::Document.batch_save(document)
+      end
+      alias update_document save_document
+
+      def save_documents(documents_array, wait_for_sync: nil, ignore_revs: nil)
+        Arango::Document.save_documents(documents_array)
+      end
+      def batch_save_documents(documents_array, wait_for_sync: nil, ignore_revs: nil)
+        Arango::Document.batch_save_documents(documents_array)
+      end
+      alias update_documents save_documents
+
+      def drop_document(document)
+        Arango::Document.drop(document, collection: self)
+      end
+      def batch_drop_document(document)
+        Arango::Document.batch_drop(document, collection: self)
+      end
+      alias delete_document drop_document
+      alias destroy_document drop_document
+      alias batch_delete_document batch_drop_document
+      alias batch_destroy_document batch_drop_document
+
+      def drop_documents(documents_array)
+        Arango::Document.drop_documents(documents_array, collection: self)
+      end
+      def batch_drop_documents(documents_array)
+        Arango::Document.batch_drop_documents(documents_array, collection: self)
+      end
+      alias delete_documents drop_documents
+      alias destroy_documents drop_documents
+      alias batch_delete_documents batch_drop_documents
+      alias batch_destroy_documents batch_drop_documents
+    end
+  end
+end

data/lib/arango/collection/edges.rb

@@ -0,0 +1,149 @@
+module Arango
+  module Collection
+    module Edges
+      # === GRAPH ===
+      def graph=(graph)
+        satisfy_class?(graph, [Arango::Graph, NilClass])
+        if !graph.nil? && graph.database.name != @database.name
+          raise Arango::Error.new err: :database_graph_no_same_as_collection_database,
+                                  data: { graph_database_name: graph.database.name, collection_database_name:  @database.name}
+        end
+        @graph = graph
+      end
+      alias assign_graph graph=
+
+      def vertex(name: nil, body: {}, rev: nil, from: nil, to: nil)
+        if @type == :edge
+          raise Arango::Error.new err: :is_a_edge_collection, data: {type:  @type}
+        end
+        if @graph.nil?
+          Arango::Document.new(name: name, body: body, rev: rev, collection: self)
+        else
+          Arango::Vertex.new(name: name, body: body, rev: rev, collection: self)
+        end
+      end
+
+      def edge(name: nil, body: {}, rev: nil, from: nil, to: nil)
+        if @type == :document
+          raise Arango::Error.new err: :is_a_document_collection, data: {type:  @type}
+        end
+        if @graph.nil?
+          Arango::Document.new(name: name, body: body, rev: rev, collection: self)
+        else
+          Arango::Edge.new(name: name, body: body, rev: rev, from: from, to: to,
+                           collection: self)
+        end
+      end
+
+      def edge_exist?
+
+      end
+      alias edge_exists? edge_exist?
+
+      def edge(name: nil, body: {}, rev: nil, from: nil, to: nil)
+        Arango::Document.new(name: name, collection: self, body: body, rev: rev,
+                             from: from, to: to)
+      end
+
+      def edges(type: "edge") # "path", "id", "key"
+        @return_edge = false
+        if type == "edge"
+          @return_edge = true
+          type = "key"
+        end
+        satisfy_category?(type, %w[path id key edge])
+        body = { type: type, collection: @name }
+        result = @database.request("PUT", "_api/simple/all-keys", body: body)
+
+        @has_more_simple = result[:hasMore]
+        @id_simple = result[:id]
+        return result if return_directly?(result)
+        return result[:result] unless @return_edge
+        if @return_edge
+          result[:result].map{|key| Arango::Document.new(name: key, collection: self)}
+        end
+      end
+
+      def insert_edge
+
+      end
+
+      def insert_edges
+
+      end
+
+      def replace_edge
+
+      end
+
+      def replace_edges(edge: {}, wait_for_sync: nil, ignore_revs: nil,
+                            return_old: nil, return_new: nil)
+        edge.each{|x| x = x.body if x.is_a?(Arango::Document)}
+        query = {
+          waitForSync: wait_for_sync,
+          returnNew:   return_new,
+          returnOld:   return_old,
+          ignoreRevs:  ignore_revs
+        }
+        result = @database.request("PUT", "_api/edge/#{@name}", body: edge,
+                                   query: query)
+        return results if return_directly?(result)
+        results.map.with_index do |result, index|
+          body2 = result.clone
+          if return_new == true
+            body2.delete(:new)
+            body2 = body2.merge(result[:new])
+          end
+          real_body = edge[index]
+          real_body = real_body.merge(body2)
+          Arango::Document.new(name: result[:_key], collection: self, body: real_body)
+        end
+      end
+
+      def update_edge
+
+      end
+
+      def update_edges(edge: {}, wait_for_sync: nil, ignore_revs: nil,
+                           return_old: nil, return_new: nil, keep_null: nil, merge_objects: nil)
+        edge.each{|x| x = x.body if x.is_a?(Arango::Document)}
+        query = {
+          waitForSync: wait_for_sync,
+          returnNew:   return_new,
+          returnOld:   return_old,
+          ignoreRevs:  ignore_revs,
+          keepNull:    keep_null,
+          mergeObject: merge_objects
+        }
+        result = @database.request("PATCH", "_api/edge/#{@name}", body: edge,
+                                   query: query, keep_null: keep_null)
+        return results if return_directly?(result)
+        results.map.with_index do |result, index|
+          body2 = result.clone
+          if return_new
+            body2.delete(:new)
+            body2 = body2.merge(result[:new])
+          end
+          real_body = edge[index]
+          real_body = real_body.merge(body2)
+          Arango::Document.new(name: result[:_key], collection: self,
+                               body: real_body)
+        end
+      end
+
+      def destroy_edge
+
+      end
+      def destroy_edges(edge: {}, wait_for_sync: nil, return_old: nil,
+                            ignore_revs: nil)
+        edge.each{|x| x = x.body if x.is_a?(Arango::Document)}
+        query = {
+          waitForSync: wait_for_sync,
+          returnOld:   return_old,
+          ignoreRevs:  ignore_revs
+        }
+        @database.request("DELETE", "_api/edge/#{@id}", query: query, body: edge)
+      end
+    end
+  end
+end

data/lib/arango/collection/importing.rb

@@ -0,0 +1,57 @@
+module Arango
+  class Collection
+    module Importing
+      # === IMPORT ===
+
+      def import_documents
+
+      end
+
+      ## maybe not
+      def import(attributes:, values:, fromPrefix: nil,
+                 toPrefix: nil, overwrite: nil, wait_for_sync: nil,
+                 onDuplicate: nil, complete: nil, details: nil)
+        satisfy_category?(onDuplicate, [nil, "error", "update", "replace", "ignore"])
+        satisfy_category?(overwrite, [nil, "yes", "true", true])
+        satisfy_category?(complete, [nil, "yes", "true", true])
+        satisfy_category?(details, [nil, "yes", "true", true])
+        query = {
+          collection:  @name,
+          fromPrefix:  fromPrefix,
+          toPrefix:    toPrefix,
+          overwrite:   overwrite,
+          waitForSync: wait_for_sync,
+          onDuplicate: onDuplicate,
+          complete:    complete,
+          details:     details
+        }
+        body = "#{attributes}\n"
+        values[0].is_a?(Array) ? values.each{|x| body += "#{x}\n"} : body += "#{values}\n"
+        @database.request("POST", "_api/import", query: query, body: body)
+      end
+
+      def import_json(body:, type: "auto", fromPrefix: nil,
+                      toPrefix: nil, overwrite: nil, wait_for_sync: nil,
+                      onDuplicate: nil, complete: nil, details: nil)
+        satisfy_category?(type, %w[auto list documents])
+        satisfy_category?(onDuplicate, [nil, "error", "update", "replace", "ignore"])
+        satisfy_category?(overwrite, [nil, "yes", "true", true])
+        satisfy_category?(complete, [nil, "yes", "true", true])
+        satisfy_category?(details, [nil, "yes", "true", true])
+        query = {
+          collection:  @name,
+          type:        type,
+          fromPrefix:  fromPrefix,
+          toPrefix:    toPrefix,
+          overwrite:   overwrite,
+          waitForSync: wait_for_sync,
+          onDuplicate: onDuplicate,
+          complete:    complete,
+          details:     details
+        }
+        @database.request("POST", "_api/import", query: query,
+                          body: body)
+      end
+    end
+  end
+end

data/lib/arango/collection/indexes.rb

@@ -0,0 +1,53 @@
+module Arango
+  class Collection
+    module Indexes
+      # === INDEXES ===
+
+      def ensure_hash_index
+
+      end
+
+      def ensure_skip_list_index
+
+      end
+
+      def ensure_geo_index
+
+      end
+
+      def ensure_fulltext_index
+
+      end
+
+      def ensure_persistent_index
+
+      end
+
+      def ensure_ttl_index
+
+      end
+
+      def index(body: {}, id: nil, type: "hash", unique: nil, fields:,
+                sparse: nil, geoJson: nil, minLength: nil, deduplicate: nil)
+        Arango::Index.new(collection: self, body: body, id: id, type: type,
+                          unique: unique, fields: fields, sparse: sparse, geo_json: geoJson,
+                          min_length: minLength, deduplicate: deduplicate)
+      end
+
+      def indexes
+        query = { collection:  @name }
+        result = @database.request("GET", "_api/index", query: query)
+        return result if return_directly?(result)
+        result[:indexes].map do |x|
+          Arango::Index.new(body: x, id: x[:id], collection: self,
+                            type: x[:type], unique: x[:unique], fields: x[:fields],
+                            sparse: x[:sparse])
+        end
+      end
+
+      def delete_index
+
+      end
+    end
+  end
+end

data/lib/arango/collection/replication.rb

@@ -0,0 +1,24 @@
+module Arango
+  class Collection
+    module Replication
+      # === REPLICATION ===
+
+      def data(batchId:, from: nil, to: nil, chunkSize: nil,
+               includeSystem: nil, failOnUnknown: nil, ticks: nil, flush: nil)
+        query = {
+          collection: @name,
+          batchId:    batchId,
+          from:       from,
+          to:         to,
+          chunkSize:  chunkSize,
+          includeSystem:  includeSystem,
+          failOnUnknown:  failOnUnknown,
+          ticks: ticks,
+          flush: flush
+        }
+        @database.request("GET", "_api/replication/dump", query: query)
+      end
+      alias dump data
+    end
+  end
+end

data/lib/arango/collection/user.rb

@@ -0,0 +1,28 @@
+module Arango
+  class Collection
+    module User
+      # === USER ACCESS ===
+
+      def check_user(user)
+        user = Arango::User.new(user: user) if user.is_a?(String)
+        return user
+      end
+      private :check_user
+
+      def add_user_access(grant:, user:)
+        user = check_user(user)
+        user.add_collection_access(grant: grant, database: @database.name, collection: @name)
+      end
+
+      def revoke_user_access(user:)
+        user = check_user(user)
+        user.clear_collection_access(database: @database.name, collection: @name)
+      end
+
+      def user_access(user:)
+        user = check_user(user)
+        user.collection_access(database: @database.name, collection: @name)
+      end
+    end
+  end
+end

data/lib/arango/cursor.rb

@@ -0,0 +1,67 @@
+module Arango
+  class Cursor
+    def has_next?
+
+    end
+
+    def next
+
+    end
+
+    def first
+
+    end
+
+    def each
+
+    end
+
+    def map
+
+    end
+
+    def filter
+
+    end
+
+    def any_match?
+
+    end
+
+    def all_match?
+
+    end
+
+    def none_match?
+
+    end
+
+    def inject
+
+    end
+
+    def remaining_as_list
+
+    end
+
+    def all_count
+      # get_count
+    end
+
+    def count
+
+    end
+
+    def stats
+
+    end
+
+    def warnings
+
+    end
+
+    def is_cached?
+
+    end
+  end
+end