ashikawa-core 0.7.2 → 0.8.0

data/lib/ashikawa-core/response_preprocessor.rb

@@ -1,5 +1,5 @@
 require "faraday"
-require "multi_json"
+require "json"
 require "ashikawa-core/exceptions/client_error"
 require "ashikawa-core/exceptions/client_error/resource_not_found"
 require "ashikawa-core/exceptions/client_error/resource_not_found/index_not_found"
@@ -51,10 +51,10 @@ module Ashikawa
       # @api private
       def resource_not_found_for(env)
         raise case env[:url].path
-          when /\A\/_api\/document/ then Ashikawa::Core::DocumentNotFoundException
-          when /\A\/_api\/collection/ then Ashikawa::Core::CollectionNotFoundException
-          when /\A\/_api\/index/ then Ashikawa::Core::IndexNotFoundException
-          else Ashikawa::Core::ResourceNotFound
+              when /\A\/_api\/document/ then Ashikawa::Core::DocumentNotFoundException
+              when /\A\/_api\/collection/ then Ashikawa::Core::CollectionNotFoundException
+              when /\A\/_api\/index/ then Ashikawa::Core::IndexNotFoundException
+              else Ashikawa::Core::ResourceNotFound
         end
       end
 
@@ -64,9 +64,9 @@ module Ashikawa
       # @return [Hash] The parsed body
       # @api private
       def parse_json(env)
-        raise MultiJson::LoadError unless json_content_type?(env[:response_headers]["content-type"])
-        MultiJson.load(env[:body])
-      rescue MultiJson::LoadError
+        raise JSON::ParserError unless json_content_type?(env[:response_headers]["content-type"])
+        JSON.parse(env[:body])
+      rescue JSON::ParserError
         raise Ashikawa::Core::JsonError
       end
 
@@ -85,12 +85,11 @@ module Ashikawa
       # @return [nil]
       # @api private
       def handle_status(env)
-        status = env[:status]
-        case status
+        case env[:status]
         when BadSyntaxStatus then raise Ashikawa::Core::BadSyntax
         when ResourceNotFoundErrorError then raise resource_not_found_for(env)
-        when ClientErrorStatuses then raise Ashikawa::Core::ClientError, status
-        when ServerErrorStatuses then raise Ashikawa::Core::ServerError, status
+        when ClientErrorStatuses then raise Ashikawa::Core::ClientError, error(env[:body])
+        when ServerErrorStatuses then raise Ashikawa::Core::ServerError, error(env[:body])
         end
       end
 
@@ -103,6 +102,16 @@ module Ashikawa
         @logger.info("#{env[:status]} #{env[:body]}")
         nil
       end
+
+      # Read the error message for the request
+      #
+      # @param [String] The raw body of the request
+      # @return [String] The formatted error message
+      # @api private
+      def error(body)
+        parsed_body = JSON.parse(body)
+        "#{parsed_body["errorNum"]}: #{parsed_body["errorMessage"]}"
+      end
     end
 
     Faraday.register_middleware :response,

data/lib/ashikawa-core/transaction.rb

@@ -0,0 +1,113 @@
+module Ashikawa
+  module Core
+    # A JavaScript Transaction on the database
+    class Transaction
+      # The collections the transaction writes to
+      #
+      # @return [Array<String>]
+      # @api public
+      # @example Get the collections that the transaction writes to
+      #   transaction.write_collections # => ["collection_1"]
+      def write_collections
+        @request_parameters[:collections][:write]
+      end
+
+      # The collections the transaction reads from
+      #
+      # @return [Array<String>]
+      # @api public
+      # @example Get the collections that the transaction reads from
+      #   transaction.read_collections # => ["collection_1"]
+      def read_collections
+        @request_parameters[:collections][:read]
+      end
+
+      # If set to true, the transaction will write all data to disk before returning
+      #
+      # @return [Boolean]
+      # @api public
+      # @example Check, if the transaction waits for sync
+      #   transaction.wait_for_sync #=> false
+      def wait_for_sync
+        @request_parameters[:waitForSync]
+      end
+
+      # If set to true, the transaction will write all data to disk before returning
+      #
+      # @param [Boolean] wait_for_sync
+      # @api public
+      # @example Activate wait sync
+      #   transaction.wait_for_sync = true
+      def wait_for_sync=(wait_for_sync)
+        @request_parameters[:waitForSync] = wait_for_sync
+      end
+
+      # An optional numeric value used to set a timeout for waiting on collection locks
+      #
+      # @return [Integer]
+      # @api public
+      # @example Check how long the lock timeout is
+      #   transaction.lock_timeout # => 30
+      def lock_timeout
+        @request_parameters[:lockTimeout]
+      end
+
+      # An optional numeric value used to set a timeout for waiting on collection locks
+      #
+      # @param [Integer] lock_timeout
+      # @api public
+      # @example Set the lock timeout to 30
+      #   transaction.lock_timeout = 30
+      def lock_timeout=(timeout)
+        @request_parameters[:lockTimeout] = timeout
+      end
+
+      # Initialize a Transaction
+      #
+      # @param [Database] database
+      # @param [String] action An action written in JavaScript
+      # @option options [Array<String>] :write The collections you want to write to
+      # @option options [Array<String>] :read The collections you want to read from
+      # @api public
+      # @example Create a Transaction
+      #   transaction = Ashikawa::Core::Transaction.new(database, "function () { return 5; }",
+      #     :read => ["collection_1"]
+      def initialize(database, action, options)
+        @database = database
+        @request_parameters = {
+          :action => action,
+          :collections => parse_options(options),
+          :waitForSync => false
+        }
+      end
+
+      # Execute the transaction
+      #
+      # @param [Object] action_params The parameters for the defined action
+      # @return Object The result of the transaction
+      # @api public
+      # @example Run a Transaction
+      #   transaction.execute({ :a => 5 })
+      def execute(action_parameters = :no_params_provided)
+        @request_parameters[:params] = action_parameters unless action_parameters == :no_params_provided
+        response = @database.send_request("transaction", :post => @request_parameters)
+        response["result"]
+      end
+
+      private
+
+      # Parse the read and write collections from the options
+      #
+      # @option options [Array<String>] :write The collections you want to write to
+      # @option options [Array<String>] :read The collections you want to read from
+      # @return [Hash]
+      # @api private
+      def parse_options(options)
+        collections = {}
+        collections[:write] = options[:write] if options.has_key? :write
+        collections[:read] = options[:read] if options.has_key? :read
+        collections
+      end
+    end
+  end
+end

data/lib/ashikawa-core/version.rb

@@ -1,6 +1,6 @@
 module Ashikawa
   module Core
     # Current version of Ashikawa::Core
-    VERSION = "0.7.2"
+    VERSION = "0.8.0"
   end
 end

data/spec/acceptance/basic_spec.rb

@@ -38,6 +38,20 @@ describe "Basics" do
       subject["volatile_collection"].volatile?.should be_true
     end
 
+    it "should create an autoincrementing collection" do
+      subject.create_collection("autoincrement_collection", :is_volatile => true, :key_options => {
+        :type => :autoincrement,
+        :increment => 10,
+        :allow_user_keys => false
+      })
+      key_options = subject["autoincrement_collection"].key_options
+
+      key_options.type.should == "autoincrement"
+      key_options.offset.should == 0
+      key_options.increment.should == 10
+      key_options.allow_user_keys.should == false
+    end
+
     it "should be possible to create an edge collection" do
       subject.create_collection("edge_collection", :content_type => :edge)
       subject["edge_collection"].content_type.should == :edge
@@ -55,6 +69,10 @@ describe "Basics" do
       subject[my_collection.id].name.should == "test_collection"
     end
 
+    it "should be possible to list all system collections" do
+      subject.system_collections.length.should > 0
+    end
+
     it "should be possible to load and unload collections" do
       my_collection = subject["test_collection"]
       my_collection.status.loaded?.should be_true
@@ -89,8 +107,8 @@ describe "Basics" do
     it "should be possible to get information about the number of documents" do
       empty_collection = subject["empty_collection"]
       empty_collection.length.should == 0
-      empty_collection << { :name => "testname", :age => 27}
-      empty_collection << { :name => "anderer name", :age => 28}
+      empty_collection.create_document({ :name => "testname", :age => 27})
+      empty_collection.create_document({ :name => "anderer name", :age => 28})
       empty_collection.length.should == 2
       empty_collection.truncate!
       empty_collection.length.should == 0
@@ -104,7 +122,7 @@ describe "Basics" do
       document["name"] = "Other Dude"
       document.save
 
-      collection[document_key]["name"].should == "Other Dude"
+      collection.fetch(document_key)["name"].should == "Other Dude"
     end
 
     it "should be possible to access and create documents from a collection" do
@@ -112,10 +130,10 @@ describe "Basics" do
 
       document = collection.create_document(:name => "The Dude", :bowling => true)
       document_key = document.key
-      collection[document_key]["name"].should == "The Dude"
+      collection.fetch(document_key)["name"].should == "The Dude"
 
-      collection[document_key] = { :name => "Other Dude", :bowling => true }
-      collection[document_key]["name"].should == "Other Dude"
+      collection.replace(document_key, { :name => "Other Dude", :bowling => true })
+      collection.fetch(document_key)["name"].should == "Other Dude"
     end
 
     it "should be possible to create an edge between two documents" do
@@ -126,7 +144,7 @@ describe "Basics" do
       b = nodes.create_document({:name => "b"})
       e = edges.create_edge(a, b, {:name => "fance_edge"})
 
-      e = edges[e.key]
+      e = edges.fetch(e.key)
       e.from_id.should == a.id
       e.to_id.should == b.id
     end
@@ -145,22 +163,32 @@ describe "Basics" do
     it "should be possible to manipulate documents and save them" do
       subject["name"] = "Jeffrey Lebowski"
       subject["name"].should == "Jeffrey Lebowski"
-      collection[document_key]["name"].should == "The Dude"
+      collection.fetch(document_key)["name"].should == "The Dude"
       subject.save
-      collection[document_key]["name"].should == "Jeffrey Lebowski"
+      collection.fetch(document_key)["name"].should == "Jeffrey Lebowski"
     end
 
     it "should be possible to delete a document" do
-      collection[document_key].delete
+      collection.fetch(document_key).delete
       expect {
-        collection[document_key]
+        collection.fetch(document_key)
       }.to raise_exception Ashikawa::Core::DocumentNotFoundException
     end
 
     it "should not be possible to delete a document that doesn't exist" do
       expect {
-        collection[123].delete
+        collection.fetch(123).delete
       }.to raise_exception Ashikawa::Core::DocumentNotFoundException
     end
+
+    it "should be possible to refresh a document" do
+      changed_document = collection.fetch(document_key)
+      changed_document["name"] = "New Name"
+      changed_document.save
+
+      subject["name"].should == "The Dude"
+      subject.refresh!
+      subject["name"].should == "New Name"
+    end
   end
 end

data/spec/acceptance/index_spec.rb

@@ -1,7 +1,8 @@
 require 'acceptance/spec_helper'
 
 describe "Indices" do
-  let(:database) { Ashikawa::Core::Database.new do |config|
+  let(:database) {
+    Ashikawa::Core::Database.new do |config|
       config.url = ARANGO_HOST
     end
   }

data/spec/acceptance/query_spec.rb

@@ -1,7 +1,8 @@
 require 'acceptance/spec_helper'
 
 describe "Queries" do
-  let(:database) { Ashikawa::Core::Database.new do |config|
+  let(:database) {
+    Ashikawa::Core::Database.new do |config|
       config.url = ARANGO_HOST
     end
   }
@@ -12,10 +13,10 @@ describe "Queries" do
       query = "FOR u IN my_collection FILTER u.bowling == true RETURN u"
       options = { :batch_size => 2, :count => true }
 
-      collection << { "name" => "Jeff Lebowski",    "bowling" => true }
-      collection << { "name" => "Walter Sobchak",   "bowling" => true }
-      collection << { "name" => "Donny Kerabatsos", "bowling" => true }
-      collection << { "name" => "Jeffrey Lebowski", "bowling" => false }
+      collection.create_document({ "name" => "Jeff Lebowski",    "bowling" => true })
+      collection.create_document({ "name" => "Walter Sobchak",   "bowling" => true })
+      collection.create_document({ "name" => "Donny Kerabatsos", "bowling" => true })
+      collection.create_document({ "name" => "Jeffrey Lebowski", "bowling" => false })
 
       names = database.query.execute(query, options).map { |person| person["name"] }
       names.should     include "Jeff Lebowski"
@@ -36,36 +37,36 @@ describe "Queries" do
     before(:each) { subject.truncate! }
 
     it "should return all documents of a collection" do
-      subject << { :name => "testname", :age => 27}
+      subject.create_document({ :name => "testname", :age => 27})
       subject.query.all.first["name"].should == "testname"
     end
 
     it "should be possible to limit and skip results" do
-      subject << { :name => "test1"}
-      subject << { :name => "test2"}
-      subject << { :name => "test3"}
+      subject.create_document({ :name => "test1"})
+      subject.create_document({ :name => "test2"})
+      subject.create_document({ :name => "test3"})
 
       subject.query.all(:limit => 2).length.should == 2
       subject.query.all(:skip => 2).length.should == 1
     end
 
     it "should be possible to query documents by example" do
-      subject << { "name" => "Random Document" }
+      subject.create_document({ "name" => "Random Document" })
       result = subject.query.by_example :name => "Random Document"
       result.length.should == 1
     end
 
     it "should be possible to query first document by example" do
-      subject << { "name" => "Single Document" }
+      subject.create_document({ "name" => "Single Document" })
       result = subject.query.first_example :name => "Single Document"
-      result.length.should == 1
+      result["name"].should == "Single Document"
     end
 
     describe "query by geo coordinates" do
       before :each do
         subject.add_index :geo, :on => [:latitude, :longitude]
-        subject << { "name" => "cologne", "latitude" => 50.948045, "longitude" => 6.961212 }
-        subject << { "name" => "san francisco", "latitude" => -122.395899, "longitude" => 37.793621 }
+        subject.create_document({ "name" => "cologne", "latitude" => 50.948045, "longitude" => 6.961212 })
+        subject.create_document({ "name" => "san francisco", "latitude" => -122.395899, "longitude" => 37.793621 })
       end
 
       it "should be possible to query documents near a certain location" do
@@ -83,9 +84,9 @@ describe "Queries" do
     describe "queries by integer ranges" do
       before :each do
         subject.add_index :skiplist, :on => [:age]
-        subject << { "name" => "Georg", "age" => 12 }
-        subject << { "name" => "Anne", "age" => 21 }
-        subject << { "name" => "Jens", "age" => 49 }
+        subject.create_document({ "name" => "Georg", "age" => 12 })
+        subject.create_document({ "name" => "Anne", "age" => 21 })
+        subject.create_document({ "name" => "Jens", "age" => 49 })
       end
 
       it "should be possible to query documents for numbers in a certain range" do

data/spec/acceptance/transactions_spec.rb

@@ -0,0 +1,30 @@
+require 'acceptance/spec_helper'
+
+describe "Transactions" do
+  subject {
+    Ashikawa::Core::Database.new do |config|
+      config.url = ARANGO_HOST
+    end
+  }
+
+  before :each do
+    subject.collections.each { |collection| collection.delete }
+    subject["collection_1"]
+    subject["collection_2"]
+    subject["collection_3"]
+  end
+
+  let(:js_function) { "function (x) { return x.a; }" }
+
+  it "should create and execute a transaction" do
+    transaction = subject.create_transaction(js_function,
+      :write => ["collection_1", "collection_2"],
+      :read =>  ["collection_3"]
+    )
+
+    transaction.wait_for_sync = true
+    transaction.lock_timeout = 14
+
+    transaction.execute({ :a => 5 }).should == 5
+  end
+end

data/spec/fixtures/collections/all.json

@@ -1,32 +1,92 @@
 {
-	"collections": [
-		{
-			"name": "example_1",
-			"waitForSync": true,
-			"id": "60768679",
-			"status": 3
-		},
-		{
-			"name": "example_2",
-			"waitForSync": true,
-			"id": "60768669",
-			"status": 3
-		}
-	],
-	"code": 200,
-	"error": false,
-	"names":{
-		"example_1": {
-			"name": "example_1",
-			"waitForSync": true,
-			"id": "60768679",
-			"status": 3
-		},
-		"example_2": {
-			"name": "example_2",
-			"waitForSync": true,
-			"id": "60768669",
-			"status": 3
-		}
-	}
+  "collections": [
+    {
+      "name": "example_1",
+      "waitForSync": true,
+      "id": "60768679",
+      "status": 3
+    },
+    {
+      "name": "example_2",
+      "waitForSync": true,
+      "id": "60768669",
+      "status": 3
+    },
+    {
+      "id": "2703783",
+      "name": "_modules",
+      "status": 2,
+      "type": 2
+    },
+    {
+      "id": "7618983",
+      "name": "_aqlfunctions",
+      "status":2,
+      "type":2
+    },
+    {
+      "id": "10699175",
+      "name": "_trx",
+      "status": 2,
+      "type": 2
+    },
+    {
+      "id": "3490215",
+      "name": "_routing",
+      "status": 3,
+      "type": 2
+    },
+    {
+      "id": "1655207",
+      "name": "_graphs",
+      "status": 2,
+      "type": 2
+    }
+  ],
+  "code": 200,
+  "error": false,
+  "names": {
+    "example_1": {
+      "name": "example_1",
+      "waitForSync": true,
+      "id": "60768679",
+      "status": 3
+    },
+    "example_2": {
+      "name": "example_2",
+      "waitForSync": true,
+      "id": "60768669",
+      "status": 3
+    },
+    "_modules": {
+      "id": "2703783",
+      "name": "_modules",
+      "status": 2,
+      "type": 2
+    },
+    "_aqlfunctions": {
+      "id": "7618983",
+      "name": "_aqlfunctions",
+      "status": 2,
+      "type": 2
+    },
+    "_trx":{
+      "id": "10699175",
+      "name": "_trx",
+      "status": 2,
+      "type": 2
+    },
+    "_routing":{
+      "id": "3490215",
+      "name": "_routing",
+      "status": 3,
+      "type": 2
+    },
+    "_graphs":{
+      "id": "1655207",
+      "name": "_graphs",
+      "status": 2,
+      "type": 2
+    }
+  }
 }