arangorb 0.1.0 → 1.0.0

data/README.md

@@ -1,111 +1,258 @@
-ArangoRB
+ArangoRB [![Gem Version](https://badge.fury.io/rb/arangorb.svg)](https://badge.fury.io/rb/arangorb)
 ===============================
 
-[ArangoDB](https://www.arangodb.com/) is a native multi-model database with flexible data models for document, graphs, and key-values.
-ArangoRB would like to be a Ruby Gem to use ArangoDB with Ruby. ArangoRB is based on the [HTTP API of ArangoDB](https://docs.arangodb.com/3.0/HTTP/index.html).
+[ArangoDatabase](https://www.arangodb.com/) is a native multi-model database with flexible data models for document, graphs, and key-values.
+ArangoRB is a Gem to use ArangoDatabase with Ruby. ArangoRB is based on the [HTTP API of ArangoDB](https://docs.arangodb.com/3.0/HTTP/index.html).
 
-ArangoRB has been tested with ArangoDB 3.0 on Ruby 2.3.1. It requires the gem "HTTParty"
+ArangoRB has been tested with ArangoDatabase 3.0 on Ruby 2.3.1. It requires the gem "HTTParty"
 
-At the moment ArangoRB is not a Gem: to install it clone the project, create a link in your project and then use
-`require_relative "./ArangoRB/ArangoRB"` in your ruby code.
+To install ArangoRB: `gem install arangorb`
 
-When it will be a gem you can use `require "arangorb"`.
+To use it in your application: `require "arangorb"`
+
+This Gem was created from [Seluxit ApS](http://seluxit.com/).
 
 ## Classes used
 
 ArangoRB has the following classes.
 
-* [ArangoS](#arangos): to manage the global variables for the management of the database
-* [ArangoDB](#arangodb): to manage a Database
-* [ArangoC](#arangoc): to manage a Collection
-* [ArangoDoc](#arangodoc): to manage a Document
-* [ArangoV](#arangov): to manage a Vertex
-* [ArangoE](#arangoe): to manage an Edge
-* [ArangoG](#arangog): to manage a Graph
-* [ArangoT](#arangot): to manage a Traverse operation
-* [ArangoAQL](#arangoaql): to manage an AQL instance
+* [ArangoServer](#ArangoServer): to manage the global variables for the management of the database
+* [ArangoDatabase](#ArangoDatabase): to manage Databases
+* [ArangoCollection](#ArangoCollection): to manage Collections
+* [ArangoDocument](#ArangoDocument): to manage Documents
+* [ArangoVertex](#ArangoVertex): to manage Vertexes
+* [ArangoEdge](#ArangoEdge): to manage Edges
+* [ArangoGraph](#ArangoGraph): to manage Graphs
+* [ArangoTraversal](#ArangoTraversal): to manage Traversal operations
+* [ArangoAQL](#arangoaql): to manage AQL instances
+* [ArangoUser](#ArangoUser): to manage Users
+* [ArangoIndex](#ArangoIndex): to manage Indexes
+* [ArangoTask](#ArangoTask): to manage Tasks
+* [ArangoTransaction](#ArangoTransaction): to manage Transactions
 
-<a name="arangos"></a>
-## ArangoS - ArangoDB Server
+<a name="ArangoServer"></a>
+## ArangoServer
 
-ArangoS is used to manage global variables for the management of the database and it is the mandatory step to start your database.
+ArangoServer is used to manage the default Database, Collection, User and Graph.
+It is used to give your login credentials and it is the mandatory step to start your database.
+Further it helps to manage the Server connected with ArangoDB.
 
-To setup your server use:
+To setup your credentials use:
 
 ``` ruby
-ArangoS.default_server user: "Username", password: "MyPass", server: "localhost", port: "8529"
+ArangoServer.default_server user: "MyUsername", password: "MyPassword", server: "localhost", port: "8529"
 ```
 
-Default value for the server are user: "root", server: "localhost", port: "8529". Password must be defined.
+If not declared, the default values are user: "root", password: "", server: "localhost", port: "8529".
 
-### Global variables
+### Default variables
 
-The databases, graphs and collections used in your program can be defined every time. But often the user needs to use only a single database, a single graph and a single collection.
-If this is the case, the user can use ArangoS to define this value once for all the ArangoRB instances.
+Databases, Graphs and Collections used in your program can be defined each time. But often it is convenient to have some default one.
+If this is the case, the user can use ArangoServer to define some default values.
 
 ``` ruby
-ArangoS.database = "MyDatabase"
-ArangoS.graph = "MyGraph"
-ArangoS.collection = "MyCollection"
+ArangoServer.database = "MyDatabase" # Setup default Database
+ArangoServer.graph = "MyGraph" # Setup default Graph
+ArangoServer.collection = "MyCollection" # Setup default Collection
+ArangoServer.user = "MyUser"  # Setup default User
 ```
 
-By default the global database is "\_system".
+By default the default database is "\_system".
 
 ### Verbose
 
-For Debugging reasons the user sometimes would like to receive the original JSON file from the database. To do this you can use the verbose command.
+For Debugging reasons the user can receive the original JSON file from the database by setting verbose on true (false by default).
 
 ``` ruby
-ArangoS.verbose = true
+ArangoServer.verbose = true
 ```
 
 Remember that verbose is only for testing reason: to work efficiently verbose should be false.
 
-<a name="arangodb"></a>
-## ArangoDB - ArangoDB Database
+### Information
+
+Basic informations can be retrieved with these command.
+
+``` ruby
+ArangoServer.database # Check name default Database
+ArangoServer.graph   # Check name default Graph
+ArangoServer.collection  # Check name default Collection
+ArangoServer.user  # Check name default User
+ArangoServer.address  # Check address used to connect with the server
+ArangoServer.username  # Check name used to connect with the server
+ArangoServer.verbose # Check if verbose is true or false
+ArangoServer.async # Check the status of async
+ArangoServer.request # Check the default request sent to the server
+```
+
+To retrieve lists
+
+``` ruby
+ArangoServer.endpoints # Lists of endpoints used
+ArangoServer.users # Lists of available users
+ArangoServer.databases # Lists of available databases
+ArangoServer.tasks # Lists of available tasks
+```
+
+To monitoring the server you can use the following commands
+
+``` ruby
+ArangoServer.log # Return log files
+ArangoServer.reload # Reloads the routing information from the collection routing.
+ArangoServer.statistics # Returns the statistics information
+ArangoServer.statistics description: true # Fetch descriptive info of statistics
+ArangoServer.role # Get to know whether this server is a Coordinator or DB-Server
+ArangoServer.serverId # Fetch this servers uniq identifier
+```
+
+### Manage Async
+
+With ArangoServer you can manage Async results.
+
+``` ruby
+ArangoServer.async = false # default
+ArangoServer.async = true # fire and forget
+ArangoServer.async = "store" # fire and store
+```
+
+If Async is "store", then the commands of ArangoRB will return the id of the Async requests.
+ArangoServer provides different methods to manage these Async requests.
+
+``` ruby
+ArangoServer.pendingAsync # Querying the status of a pending job
+ArangoServer.fetchAsync id: id # Fetches a job result and removes it from the queue
+ArangoServer.retrieveAsync id: id # Returns the status of a specific job
+ArangoServer.retrieveAsync type: type # Returns the ids of job results with a specific status
+# Type can be "done" or "pending"
+ArangoServer.retrieveDoneAsync # Equivalent to ArangoServer.retrieveAsync type: "done"
+ArangoServer.retrievePendingAsync # Equivalent to ArangoServer.retrieveAsync type: "pending"
+ArangoServer.cancelAsync id: id # Cancels an async job
+ArangoServer.destroyAsync id: id # Deletes an async job result
+ArangoServer.destroyAsync type: type # Deletes async jobs with a specific status
+# Type can be "all" or "expired"
+ArangoServer.destroyAllAsync # Equivalent to ArangoServer.destroyAsync type: "all"
+ArangoServer.destroyExpiredAsync # Equivalent to ArangoServer.destroyAsync type: "expired"
+```
+
+### Batch
+
+ArangoDB offers a batch request API that clients can use to send multiple operations in one batch to ArangoDB. To manage it you can use the following way.
+
+``` ruby
+queries = [
+  {
+    "type": "POST",
+    "address": "/_db/MyDatabase/_api/collection",
+    "body": {"name": "newCOLLECTION"},
+    "id": "1"
+  },
+  {
+    "type": "GET",
+    "address": "/_api/database",
+    "id": "2"
+  }
+]
+ArangoServer.batch queries: queries
+```
+
+To manage these batch, ArangoServer offers the following functions:
 
-ArangoDB is used to manage your Database. You can create an instance in the following way:
+``` ruby
+ArangoServer.createDumpBatch ttl: 10 # Create a new dump batch with 10 second time-to-live (return id of the dumpBatch)
+ArangoServer.prolongDumpBatch id: idDumpBatch, ttl: 20 # Prolong the life of a batch for 20 seconds
+ArangoServer.destroyDumpBatch id: idDumpBatch # Delete a selected batch
+```
+
+### Miscellaneous
+
+``` ruby
+ArangoServer.version # Returns the server version number
+ArangoServer.flushWAL # Flushes the write-ahead log
+ArangoServer.propertyWAL # Retrieves the configuration of the write-ahead log
+ArangoServer.changePropertyWAL # Configures the write-ahead log
+ArangoServer.transactions # Returns information about the currently running transactions
+ArangoServer.time # Get the current time of the system
+ArangoServer.echo # Return current request
+ArangoServer.databaseVersion # Return the required version of the database
+ArangoServer.sleep duration: 10 # Sleep for a specified amount of seconds
+ArangoServer.shutdown # Initiate shutdown sequence
+ArangoServer.restart # Restart ArangoDB (requires administration access)
+```
+
+UNTESTED
+
+``` ruby
+ArangoServer.test body: body # Runs tests on server
+ArangoServer.execute body: body # Execute a script on the server.
+```
+
+### Sharding (UNTESTED)
+
+ArangoDB permits the sharding of the database. Although these methods has not been tested with ArangoRB.
+
+``` ruby
+ArangoServer.cluster # Default cluster
+ArangoServer.getCluster body: body, cluster: cluster # Retrieve cluster
+ArangoServer.executeCluster body: body, cluster: cluster # Execute cluster
+ArangoServer.executeClusterPut body: body, cluster: cluster # Execute cluster
+ArangoServer.executeClusterHead body: body, cluster: cluster # Execute cluster
+ArangoServer.destroyCluster cluster: cluster # Delete cluster
+ArangoServer.updateCluster body: body, cluster: cluster # Update cluster
+ArangoServer.checkPort port: port # Allows to check whether a given port is usable
+ArangoServer.server # Returns the id of a server in a cluster.
+ArangoServer.clusterStatistics dbserver: dbserver # Allows to query the statistics of a DBserver in the cluster
+```
+
+<a name="ArangoDatabase"></a>
+## ArangoDatabase
+
+ArangoDatabase is used to manage your Database. You can create an instance in the following way:
 
 ``` ruby
-myDatabase = ArangoDB.new(database: "MyDatabase")
+myDatabase = ArangoDatabase.new database: "MyDatabase"
 ```
 
-Alternatively, you can use ArangoS:
+Alternatively, you can use the default values provided by ArangoServer:
 
 ``` ruby
-ArangoS.database = "MyDatabase"
-myDatabase = ArangoDB.new
+ArangoServer.database = "MyDatabase"
+myDatabase = ArangoDatabase.new
 ```
 
 ### Create and Destroy a Database
 
 ``` ruby
-myDatabase.create
-mmyDatabase.destroy
+myDatabase.create # Create a new Database
+myDatabase.destroy # Delete the selected Database
 ```
 
 ### Retrieve information
 
 ``` ruby
-ArangoDB.info # Obtain general info about the databases
-ArangoDB.databases # Obtain an Array with the available databases
+ArangoDatabase.info # Obtain general info about the databases
+ArangoDatabase.databases # Obtain an Array with the available databases
 myDatabase.collections # Obtain an Array with the available collections in the selected Database
 myDatabase.graphs #  Obtain an Array with the available graphs in the selected Database
+myDatabase.functions #  Obtain an Array with the available functions in the selected Database
 ```
 
 ### Query
 
+ArangoDatabase instances can manage the queries used in their Database.
+
 ``` ruby
 myDatabase.propertiesQuery; # See property of the Query
 myDatabase.currentQuery; # Check the current Query
 myDatabase.slowQuery; # Find slow queries
 myDatabase.stopSlowQuery; # Stop slow queries
-myDatabase.kill id: myQuery.id # Kill a Query
+myDatabase.kill query: myQuery # Kill a Query
 myDatabase.changePropertiesQuery maxSlowQueries: 65 # Change properties of a Query
 ```
 
 ### Cache
 
+To manage the cache ArangoDatabase provides the following three functions.
+
 ``` ruby
 myDatabase.clearCache # Clear Cache
 myDatabase.propertyCache # Check properties Cache
@@ -119,22 +266,50 @@ myDatabase.createFunction code: "function(){return 1+1;}", name: "myFunction" #
 myDatabase.deleteFunction name: "myFunction" # Delete a function
 myDatabase.functions # Retrieve a list of the available functions
 ```
-<a name="arangoc"></a>
-## ArangoC - ArangoDB Collection
 
-ArangoDB is used to manage your Collections. You can create an ArangoC instance in one of the following way:
+### User
+
+You can manage the right of a user to access the database.
+
+``` ruby
+@myDatabase.grant user: myUser # Grant access to database
+@myDatabase.revoke user: myUser # Revoke access to database
+```
+
+### Replication (UNTESTED)
+
+``` ruby
+@myDatabase.inventory # Returns an overview of collections and their indexes
+@myDatabase.clusterInventory # Return cluster inventory of collections and indexes
+@myDatabase.logger # Return replication logger state
+@myDatabase.loggerFollow # Returns log entries
+@myDatabase.firstTick # Returns the first available tick value
+@myDatabase.rangeTick # Return the tick ranges available in the WAL logfiles
+@myDatabase.sync # Synchronize data from a remote endpoint
+@myDatabase.configurationReplication # Return configuration of replication applier
+@myDatabase.modifyConfigurationReplication # Adjust configuration of replication applier
+@myDatabase.startReplication # Start replication applier
+@myDatabase.stateReplication # State of the replication applier
+@myDatabase.stopReplication # Stop replication applier
+@myDatabase.enslave # Turn the server into a slave of another
+```
+
+<a name="ArangoCollection"></a>
+## ArangoCollection
+
+ArangoDatabase is used to manage your Collections. You can create an ArangoCollection instance in one of the following way:
 
 ``` ruby
-myCollection = ArangoC.new(database: "MyDatabase", collection: "MyCollection")
-myCollection = ArangoC.new(collection: "MyCollection") # If the database has been already defined with ArangoS
-myCollection = ArangoC.new # If the database and the collection have been already defined with ArangoS
+myCollection = ArangoCollection.new database: "MyDatabase", collection: "MyCollection"
+myCollection = ArangoCollection.new collection: "MyCollection"  # Using the default database
+myCollection = ArangoCollection.new # Using the default database and collection
 ```
 
 A Collection can be of two types: "Document" and "Edge". If you want to specify it, uses:
 
 ``` ruby
-myCollectionA = ArangoC.new collection: "MyCollectionA", type: "Document"
-myCollectionB = ArangoC.new collection: "MyCollectionB", type: "Edge"
+myCollectionA = ArangoCollection.new collection: "MyCollectionA", type: "Document"
+myCollectionB = ArangoCollection.new collection: "MyCollectionB", type: "Edge"
 ```
 
 ### Create a Collection
@@ -146,13 +321,13 @@ To create an Edge Collection you can use one of the next three options:
 
 ``` ruby
 myCollection.create_edge_collection
-myCollection.create type: 3
-myCollectionB = ArangoC.new(collection: "MyCollectionB", type: "Edge");  myCollectionB.create
+myCollection.create type: "Edge"
+myCollectionB = ArangoCollection.new collection: "MyCollectionB", type: "Edge";  myCollectionB.create
 ```
 
 ### Destroy or Truncate a Collections
 
-Destroy will delete from the Database the selected Collection.
+Destroy will delete the selected Collection from the Database.
 
 `myCollection.destroy`
 
@@ -164,10 +339,13 @@ Truncate will delete all the Documents inside the selected Collection.
 
 ``` ruby
 myCollection.retrieve # Retrieve the selected Collection
+myCollection.indexes # Return a list of all used Indexes in the Collection
+myCollection.data # Returns the whole content of one collection
 myCollection.properties # Properties of the Collection
 myCollection.count # Number of Documents in the Collection
 myCollection.stats # Statistics of the Collection
-myCollection.checksum
+myCollection.revision # Return collection revision id
+myCollection.checksum # Return checksum for the Collection
 ```
 
 To retrieve the documents of a Collection you can use:
@@ -181,7 +359,7 @@ These two functions are similar except for the fact that you can assign differen
 
 `myCollection.documents type: "path"`
 
-Type can be "path", "id" or "key" in relation what we wish to have. If not specified we will receive an array of ArangoDoc instances.
+Type can be "path", "id" or "key" in relation what we wish to have. If not specified we will receive an array of ArangoDocument instances.
 
 `myCollection.allDocuments skip: 3, limit: 100, batchSize: 10`
 
@@ -203,6 +381,48 @@ myCollection.load # Load the Collection
 myCollection.unload  # Unload the Collection
 myCollection.change waitForSync: true  # Change a property of the Collection
 myCollection.rename "myCollectionC"  # Rename the Collection
+myCollection.rotate # Rotate journal of a collection
+```
+
+### Import and Export Documents
+
+For the standard way to import one or more Documents (or Edges) we refer to the [dedicated ArangoDocument section](#create_doc).
+However it is possible to import a huge quantity of documents in a Collection with only one requests with the command import.
+
+<strong>Import one Document with Array</strong>
+I import one document with the following structure {"value": "uno", "num": 1, "name": "ONE"}.
+``` ruby
+attributes = ["value", "num", "name"]
+values = ["uno",1,"ONE"]
+myCollection.import attributes: attributes, values: values
+```
+
+<strong>Import more Documents with Array</strong>
+I import three Documents with the following structure {"value": "uno", "num": 1, "name": "ONE"}, {"value": "due", "num": 2, "name": "TWO"}, {"value": "tre", "num": 3, "name": "THREE"}.
+``` ruby
+attributes = ["value", "num", "name"]
+values = [["uno",1,"ONE"],["due",2,"TWO"],["tre",3,"THREE"]]
+myCollection.import attributes: attributes, values: values
+```
+
+<strong>Import more Documents with JSON</strong>
+I import two Documents with the following structure {"value": "uno", "num": 1, "name": "ONE"}, {"value": "due", "num": 2, "name": "TWO"}.
+``` ruby
+body = [{"value": "uno", "num": 1, "name": "ONE"}, {"value": "due", "num": 2, "name": "DUE"}]
+myCollection.importJSON body: body
+```
+
+As it is possible to import files, it is possible to export all the Document of a Collection with the following command.
+``` ruby
+myCollection.export
+```
+
+Alternatively it is possible to retrieve all the Documents in a Collection gradually.
+
+``` ruby
+myCollection.export batchSize: 3 # First three Documents of the Collection
+myCollection.exportNext # Next three Documents
+myCollection.exportNext # Next three Documents
 ```
 
 ### Other operations
@@ -214,60 +434,59 @@ myCollection.replaceMatch match: {"value" => 4}, newValue: {"value" => 6} # All
 myCollection.updateMatch match: {"value" => 4}, newValue: {"value" => 6} # All Documents of the Collection with value equal to 4 will be updated with the new Value
 ```
 
-<a name="arangodoc"></a>
-## ArangoDoc - ArangoDB Document
+<a name="ArangoDocument"></a>
+## ArangoDocument
 
 An Arango Document is an element of a Collection. Edges are documents with "\_from" and "\_to" in their body.
-You can create an ArangoC instance in one of the following way:
+You can create an ArangoCollection instance in one of the following way:
 
 ``` ruby
-myDocument = ArangoDoc.new(database: "MyDatabase", collection: "MyCollection", key: "myKey")
-myDocument = ArangoDoc.new(collection: "MyCollection", key: "myKey") # If the database has been already defined with ArangoS
-myDocument = ArangoDoc.new(collection: myCollection, key: "myKey") # If the database has been already defined with ArangoS and myCollection is an ArangoC instance
-myDocument = ArangoDoc.new(key: "myKey") # If the database and the collection have been already defined with ArangoS
-myDocument = ArangoDoc.new # If the database and the collection have been already defined with ArangoS and I don't want to define a key for my Instance
+myDocument = ArangoDocument.new database: "MyDatabase", collection: "MyCollection", key: "myKey"
+myDocument = ArangoDocument.new collection: "MyCollection", key: "myKey"  # Using default Database
+myDocument = ArangoDocument.new key: "myKey" # Using default Collection and Database
+myDocument = ArangoDocument.new #  Using default Collection and Database and I don't want to define a key for my Instance
 ```
 
-In the case you want to define a Edge, it is convenient to introduce them during the instance.
+In the case you want to define a Edge, it is convenient to introduce the parameters "from" and "to" in the instance.
 
 ``` ruby
-myEdge = ArangoDoc.new from: myDocA, to: myDocB
+myEdge = ArangoDocument.new from: myDocA, to: myDocB
 ```
 
-where myDocA and myDocB are the IDs of two Documents or are two ArangoDoc instances.
-
-When you do the instance of an ArangoDoc is a good idea to define a Body for the Document you want:
+where myDocA and myDocB are the IDs of two Documents or are two ArangoDocument instances.
+During the instance, it is possible to define a Body for the Document.
 
 ``` ruby
-myDocument = ArangoDoc.new(body: {"value" => 17})
+myDocument = ArangoDocument.new body: {"value" => 17}
 ```
 
+<a name="create_doc"></a>
 ### Create one or more Documents
 
-You have three way to create a single Document.
+ArangoRB provides several way to create a single Document.
 
 ``` ruby
 myDocument.create
-myCollection.create_document document: myDocument # myDocument is an ArangoDoc instance or a Hash
-ArangoDoc.create(body: {"value" => 17}, collection: myDocument)
+myCollection.create_document document: myDocument # myDocument is an ArangoDocument instance or a Hash
+ArangoDocument.create body: {"value" => 17}, collection: myDocument
 ```
 
-You have two way to create more Documents.
+Or more Documents.
 
 ``` ruby
-myCollection.create_document document: [myDocumentA, myDocumentB, {"value" => 17}] # Array of ArangoDoc instances and Hashes
-ArangoDoc.create(body: [{"value" => 17}, {"value" => 18}, {"value" => 3}], collection: myDocument)  # Array of only Hashes
+myCollection.create_document document: [myDocumentA, myDocumentB, {"value" => 17}] # Array of ArangoDocument instances and Hashes
+ArangoDocument.create body: [myDocumentA, {"value" => 18}, {"value" => 3}], collection: myDocument  # Array of ArangoDocument instances and Hash
 ```
 
 ### Create one or more Edges
 
-We have different way to create one or multiple edges. Here some example:
+ArangoRB has different way to create one or multiple edges. Here some example:
 
 ``` ruby
-myEdge = ArangoDoc.new from: myDocA, to: myDocB; myEdge.create
-myEdge.create_edge from: myDocA, to: myDocB # myDocA and myDocB are ArangoDoc ids or ArangoDoc instances
+myEdge = ArangoDocument.new from: myDocA, to: myDocB; myEdge.create
+myEdge.create_edge from: myDocA, to: myDocB # myDocA and myDocB are ArangoDocument ids or ArangoDocument instances
 myEdgeCollection.create_edge document: myEdge, from: myDocA, to: myDocB
-ArangoDoc.create_edge(body: {"value" => 17}, from: myDocA, to: myDocB, collection: myEdgeCollection)
+ArangoDocument.create_edge body: {"value" => 17}, from: myDocA, to: myDocB, collection: myEdgeCollection
 ```
 
 Further we have the possibility to create different combination of Edges in only one line of code
@@ -325,7 +544,7 @@ myDocument.destroy
 
 ``` ruby
 myDocument.retrieve # Retrieve Document
-myDocument.retrieve_edges(collection: myEdgeCollection) # Retrieve all myEdgeCollection edges connected with the Document
+myDocument.retrieve_edges collection: myEdgeCollection  # Retrieve all myEdgeCollection edges connected with the Document
 myDocument.any(myEdgeCollection) # Retrieve all myEdgeCollection edges connected with the Document
 myDocument.in(myEdgeCollection)  # Retrieve all myEdgeCollection edges coming in the Document
 myDocument.out(myEdgeCollection) # Retrieve all myEdgeCollection edges going out the Document
@@ -366,15 +585,15 @@ myDocument.update body: {"value" => 3} # We update or add a value
 myDocument.replace body: {"value" => 3} # We replace a value
 ```
 
-<a name="arangog"></a>
-## ArangoG - ArangoDB Graph
+<a name="ArangoGraph"></a>
+## ArangoGraph
 
-ArangoG are used to manage graphs. You can create an ArangoG instance in one of the following way:
+ArangoGraph are used to manage Graphs. You can create an ArangoGraph instance in one of the following way.
 
 ``` ruby
-myGraph = ArangoG.new(database: "MyDatabase", graph: "MyGraph")
-myGraph = ArangoG.new(graph: "MyGraph") # If the database has been already defined with ArangoS
-myGraph = ArangoG.new # If the database and the graph have been already defined with ArangoS
+myGraph = ArangoGraph.new database: "MyDatabase", graph: "MyGraph"
+myGraph = ArangoGraph.new graph: "MyGraph" # By using the default Database
+myGraph = ArangoGraph.new # By using the defauly Database and Graph
 ```
 
 ### Create, Retrieve and Destroy a Graph
@@ -389,32 +608,32 @@ myGraph.destroy # destroy the Graph
 
 ``` ruby
 myGraph.vertexCollections # Retrieve all the vertexCollections of the Graph
-myGraph.addVertexCollection(collection: "myCollection") # Add a Vertex Collection to our Graph
-myGraph.removeVertexCollection(collection: "myCollection") # Remove a Vertex Collection to our Graph
+myGraph.addVertexCollection collection: "myCollection"  # Add a Vertex Collection to our Graph
+myGraph.removeVertexCollection collection: "myCollection"  # Remove a Vertex Collection to our Graph
 ```
 
 ### Manage Edge Collections
 
 ``` ruby
 myGraph.edgeCollections # Retrieve all the edgeCollections of the Graph
-myGraph.addEdgeCollections(collection: "myEdgeCollection", from: "myCollectionA", to: "myCollectionB") # Add an Edge Collection to our Graph
-myGraph.replaceEdgeCollections(collection: "myEdgeCollection", from: "myCollectionA", to: "myCollectionB") # Replace an Edge Collection to our Graph
-myGraph.removeEdgeCollections(collection: "myEdgeCollection") # Remove an Edge Collection to our Graph
+myGraph.addEdgeCollections collection: "myEdgeCollection", from: "myCollectionA", to: "myCollectionB"  # Add an Edge Collection to our Graph
+myGraph.replaceEdgeCollections collection: "myEdgeCollection", from: "myCollectionA", to: "myCollectionB"  # Replace an Edge Collection to our Graph
+myGraph.removeEdgeCollections collection: "myEdgeCollection"  # Remove an Edge Collection to our Graph
 ```
 
-<a name="arangov"></a><a name="arangoe"></a>
-## ArangoV - ArangoDB Vertex and ArangoE - ArangoDB Edge
+<a name="ArangoVertex"></a><a name="ArangoEdge"></a>
+## ArangoVertex and ArangoEdge
 
-Both these two classes inherit the class ArangoDoc.
-These two classes have been created since ArangoDB offers, in connection of the chosen graph, other possible HTTP requests to fetch Vertexes and Edges. We recommend the reader to read carefully the section on ArangoDoc instances before to use ArangoV and ArangoE instances. 
+Both these two classes inherit the class ArangoDocument.
+These two classes have been created since ArangoDatabase offers, in connection of the chosen graph, different HTTP requests to manage Vertexes and Edges. We recommend the reader to read carefully the section on [ArangoDocument instances](#ArangoDocument) before to start to use ArangoVertex and ArangoEdge instances.
 
-### ArangoV methods
+### ArangoVertex methods
 
-ArangoV inherit all the methods of ArangoDoc class. The following one works similar to the one of ArangoDoc Class but use a different HTTP request. For this reason the performance could be different.
-To use ArangoV, the Collection of the Vertex needs to be added to the VertexCollections of the chosen Graph.
+ArangoVertex inherit all the methods of ArangoDocument class. The following one works similar to the one of ArangoDocument Class but use different HTTP requests. For this reason the performance could be different.
+To use ArangoVertex, the Collection of the Vertex needs to be added either to the VertexCollections or to the EdgeCollections of the chosen Graph.
 
 ``` ruby
-myVertex = ArangoV.new key: "newVertex", body: {"value" => 3}, collection: "myCollection", graph: "myGraph", database: "myDatabase"
+myVertex = ArangoVertex.new key: "newVertex", body: {"value" => 3}, collection: "myCollection", graph: "myGraph", database: "myDatabase" # create a new instance
 myVertex.create # create a new Document in the Graph
 myVertex.retrieve  # retrieve a Document
 myVertex.replace body: {"value" => 6} # replace the Document
@@ -422,13 +641,13 @@ myVertex.update body: {"value" => 6} # update the Document
 myVertex.destroy # delete the Document
 ```
 
-### ArangoE methods
+### ArangoEdge methods
 
-ArangoE inherit all the methods of ArangoDoc class. The following one works similar to the one of ArangoDoc Class but use a different HTTP request. For this reason the performance could be different.
-To use ArangoE, the Collection of the Edge needs to be added to the EdgeCollections of the chosen Graph.
+ArangoEdge inherit all the methods of ArangoDocument class. The following one works similar to the one of ArangoDocument Class but use a different HTTP request. For this reason the performance could be different.
+To use ArangoEdge, the Collection of the Edge needs to be added to the EdgeCollections of the chosen Graph.
 
 ``` ruby
-myEdge = ArangoE.new key: "newVertex", body: {"value" => 3}, from: myArangoDoc, to: myArangoDoc, collection: "myCollection", graph: "myGraph", database: "myDatabase"
+myEdge = ArangoEdge.new key: "newVertex", body: {"value" => 3}, from: myArangoDocument, to: myArangoDocument, collection: "myCollection", graph: "myGraph", database: "myDatabase" # create a new instance
 myEdge.create # create a new Document of type Edge in the Graph
 myEdge.retrieve # retrieve a Document
 myEdge.replace body: {"value" => 6} # replace the Document
@@ -436,37 +655,37 @@ myEdge.update body: {"value" => 6} # update the Document
 myEdge.destroy # delete the Document
 ```
 
-<a name="arangot"></a>
-## ArangoT - ArangoDB Transaction
+<a name="ArangoTraversal"></a>
+## ArangoTraversal
 
-ArangoT is used to administrate the transaction.
-ArangoT needs to know the vertex from where the transaction starts, the direction the transaction is going and either the Graph or the EdgeCollection we want to analize.
+ArangoTraversal is used to administrate the traversals.
+ArangoTraversal needs to know the vertex from where the traversal starts, the direction the traversal is going and either the Graph or the EdgeCollection we want to analize.
 
 ``` ruby
-myTransaction = ArangoT.new # create new ArangoTransaction
-myTransaction.vertex = myVertex # define starting Vertex
-myTransaction.graph = myGraph  # define used Graph
-myTransaction.edgeCollection = myEdgeCollection # define used Edge
-myTransaction.in # Direction is in
-myTransaction.out  # Direction is out
-myTransaction.any  # Direction is in and out
-myTransaction.min = 1 # Define how minimum deep we want to go with the transaction
-myTransaction.max = 3 # Define how maximum deep we want to go with the transaction
+myTraversal = ArangoTraversal.new # create new ArangoTraversal
+myTraversal.vertex = myVertex # define starting Vertex
+myTraversal.graph = myGraph  # define used Graph
+myTraversal.edgeCollection = myEdgeCollection # define used Edge
+myTraversal.in # Direction is in
+myTraversal.out  # Direction is out
+myTraversal.any  # Direction is in and out
+myTraversal.min = 1 # Define how minimum deep we want to go with the traversal
+myTraversal.max = 3 # Define how maximum deep we want to go with the traversal
 ```
 
-After the transaction is setup, you can execute it:
+After the traversal is setup, you can execute it:
 
 ``` ruby
-myTransaction.execute
+myTraversal.execute
 ```
 
 <a name="arangoaql"></a>
-## ArangoAQL - ArangoDB Query Language
+## ArangoAQL - ArangoDatabase Query Language
 
-ArangoAQL is used to manage the ArangoDB query languages. To instantiate a query use:
+ArangoAQL is used to manage the ArangoDB query language. To instantiate a query
 
 ``` ruby
-myQuery = ArangoAQL.new(query: "FOR v,e,p IN 1..6 ANY 'Year/2016' GRAPH 'MyGraph' FILTER p.vertices[1].num == 6 && p.vertices[2].num == 22 && p.vertices[6]._key == '424028e5-e429-4885-b50b-007867208c71' RETURN [p.vertices[4].value, p.vertices[5].data]")
+myQuery = ArangoAQL.new query: "FOR v,e,p IN 1..6 ANY 'Year/2016' GRAPH 'MyGraph' FILTER p.vertices[1].num == 6 && p.vertices[2].num == 22 && p.vertices[6]._key == '424028e5-e429-4885-b50b-007867208c71' RETURN [p.vertices[4].value, p.vertices[5].data]"
 ```
 
 To execute it use:
@@ -474,7 +693,7 @@ To execute it use:
 myQuery.execute
 ```
 
-If the query is too big, you can divide the fetching in piece, for example:
+If the query is too big, you can divide the fetching in pieces, for example:
 ``` ruby
 myQuery.size = 10
 myQuery.execute # First 10 documents
@@ -499,3 +718,79 @@ myQuery.changeProperties maxSlowQueries: 65 # Change Properties
 myQuery.stopSlow; # Stop Slow query
 myQuery.kill; # Kill Query
 ```
+
+<a name="ArangoUser"></a>
+## ArangoUser
+
+ArangoUser manages the users.
+To initialize an user:
+
+``` ruby
+myUser = ArangoUser.new user: "MyUser", password: "password"
+```
+
+### User management
+
+``` ruby
+myUser.retrieve # Retrieve User
+myUser.create # Create a new User
+myUser.replace active: false # Replace User
+myUser.update active: false # Update User
+myUser.destroy # Delete User
+```
+
+### Database management
+
+``` ruby
+myUser.databases # Check permission Databases
+myUser.grant database: "MyDatabase" # Grant access to a database
+myUser.revoke database: "MyDatabase" # Revoke access to a database
+```
+
+<a name="ArangoIndex"></a>
+## ArangoIndex
+
+ArangoIndex manages the indexes.
+To initialize an index:
+
+``` ruby
+myIndex = ArangoIndex.new fields: "num", unique: false, id: "myIndex"
+```
+
+### Index management
+
+``` ruby
+myIndex.retrieve # Retrieve Index
+myIndex.create # Create a new Index
+ArangoIndex.indexes collection: "MyCollection" # List indexes
+myIndex.destroy # Delete Index
+```
+
+Alternatively, you can create an Index of a Collection directly from its Collection.
+
+``` ruby
+myCollection.createIndex unique: false, fields: "num", type: "hash"
+```
+
+<a name="ArangoTransaction"></a>
+## ArangoTransaction
+
+Transactions are managed by ArangoTransaction. This class has only initialization and execution.
+
+``` ruby
+myArangoTransaction = ArangoTransaction.new action: "function(){ var db = require('@arangodb').db; db.MyCollection.save({}); return db.MyCollection.count(); }", write: myCollection # Or read
+myArangoTransaction.execute # Return the result of the execution
+```
+
+<a name="ArangoTask"></a>
+## ArangoTask
+
+Tasks are managed by ArangoTask.
+
+``` ruby
+myArangoTask = ArangoTask.new id: "mytaskid", name: "MyTaskID", command: "(function(params) { require('@arangodb').print(params); })(params)", params: {"foo" => "bar", "bar" => "foo"}, period: 2 # Initialize a  Task Instance that will be alive for 2 seconds
+myArangoTask.create # Create a new Task
+ArangoTask.tasks # Retrieve a list of active tasks
+myArangoTask.retrieve # Retrieve a Task
+myArangoTask.destroy # Delete a Task
+```