ashikawa-core 0.1

data/lib/ashikawa-core/connection.rb

@@ -0,0 +1,68 @@
+require "rest-client"
+require "json"
+
+module Ashikawa
+  module Core
+    # Represents a Connection via HTTP to a certain host
+    class Connection
+      # The IP of the connection
+      # 
+      # @return [String]
+      # @api public
+      # @example Get the IP of the connection
+      #   connection = Connection.new "http://localhost:8529"
+      #   connection.ip # => "http://localhost"
+      attr_reader :ip
+      
+      # The port of the connection
+      # 
+      # @return [Fixnum]
+      # @api public
+      # @example Get the port of the connection
+      #   connection = Connection.new "http://localhost:8529"
+      #   connection.port # => 8529
+      attr_reader :port
+      
+      # Initialize a Connection with a given API String
+      # 
+      # @param [String] api_string IP and Port as a String
+      # @api public
+      # @example Create a new Connection
+      #  connection = Connection.new "http://localhost:8529"
+      def initialize(api_string)
+        @api_string = api_string
+        @ip, @port = @api_string.scan(/(\S+):(\d+)/).first
+        @port = @port.to_i
+      end
+      
+      # Sends a request to a given path (Prepends the api_string automatically)
+      # 
+      # @example get request 
+      #   connection.send_request('/collection/new_collection')
+      # @example post request
+      #   connection.send_request('/collection/new_collection', :post => { :name => 'new_collection' })
+      # @param [String] path the path you wish to send a request to.
+      # @param [Hash] method_params additional parameters for your request. Only needed if you want to send something other than a GET request.
+      # @option method_params [Hash] :post POST data in case you want to send a POST request.
+      # @return [Hash] parsed JSON response from the server
+      # @api semipublic
+      def send_request(path, method_params = {})
+        path.gsub! /^\//, ''
+        
+        if method_params.has_key? :post
+          JSON.parse RestClient.post("#{@api_string}/_api/#{path}", method_params[:post].to_json )
+        elsif method_params.has_key? :put
+          JSON.parse RestClient.put("#{@api_string}/_api/#{path}", method_params[:put].to_json )
+        elsif method_params.has_key? :delete
+          if method_params[:delete] = {}
+            JSON.parse RestClient.delete("#{@api_string}/_api/#{path}" )
+          else
+            JSON.parse RestClient.delete("#{@api_string}/_api/#{path}", method_params[:delete].to_json )
+          end
+        else
+          JSON.parse RestClient.get("#{@api_string}/_api/#{path}")
+        end
+      end
+    end
+  end
+end

data/lib/ashikawa-core/database.rb

@@ -0,0 +1,98 @@
+require "ashikawa-core/collection"
+require "ashikawa-core/connection"
+
+module Ashikawa
+  module Core
+    # Represents an ArangoDB database in Ruby
+    class Database
+      # Initializes the connection to the database
+      # 
+      # @param [Connection, String] connection A Connection object or a String to create a Connection object.
+      # @api public
+      # @example Access a Database by providing the URL
+      #  database = Ashikawa::Core::Database.new "http://localhost:8529"
+      # @example Access a Database by providing a Connection
+      #  connection = Connection.new "http://localhost:8529"
+      #  database = Ashikawa::Core::Database.new connection
+      def initialize(connection)
+        if connection.class == String
+          @connection = Ashikawa::Core::Connection.new connection
+        else
+          @connection = connection
+        end
+      end
+      
+      # The IP of the database
+      # 
+      # @return [String]
+      # @api public
+      # @example Get the IP of the connection
+      #   database = Ashikawa::Core::Database.new "http://localhost:8529"
+      #   database.ip # => http://localhost
+      def ip
+        @connection.ip
+      end
+      
+      # The Port of the database
+      # 
+      # @return [Fixnum]
+      # @api public
+      # @example Get the port for the connection
+      #   database = Ashikawa::Core::Database.new "http://localhost:8529"
+      #   database.port # => 8529
+      def port
+        @connection.port
+      end
+      
+      # Returns a list of all collections defined in the database
+      # 
+      # @return [Array<Collection>]
+      # @api public
+      # @example Get an Array containing the Collections in the database
+      #   database = Ashikawa::Core::Database.new "http://localhost:8529"
+      #   database["a"]
+      #   database["b"]
+      #   database.collections # => [ #<Collection name="a">, #<Collection name="b">]
+      def collections
+        server_response = @connection.send_request "/collection"
+        server_response["collections"].map { |collection| Ashikawa::Core::Collection.new self, collection }
+      end
+      
+      # Get or create a Collection based on name or ID
+      # 
+      # @param [String, Fixnum] collection_identifier The name or ID of the collection
+      # @return [Collection]
+      # @api public
+      # @example Get a Collection from the database by name
+      #   database = Ashikawa::Core::Database.new "http://localhost:8529"
+      #   database["a"] # => #<Collection name="a">
+      # @example Get a Collection from the database by ID
+      #   database = Ashikawa::Core::Database.new "http://localhost:8529"
+      #   database["7254820"] # => #<Collection id=7254820>
+      def [](collection_identifier)
+        begin
+          server_response = @connection.send_request "/collection/#{collection_identifier}"
+        rescue RestClient::ResourceNotFound
+          server_response = @connection.send_request "/collection", post: { name: collection_identifier }
+        end
+        
+        Ashikawa::Core::Collection.new self, server_response
+      end
+      
+      # Sends a request to a given path (Prepends the api_string automatically)
+      # 
+      # @example Send a get request to the database
+      #   connection.send_request('/collection/new_collection')
+      # @example Send a post request to the database
+      #   connection.send_request('/collection/new_collection', :post => { :name => 'new_collection' })
+      # @param [String] path the path you wish to send a request to.
+      # @param [Hash] method_params additional parameters for your request. Only needed if you want to send something other than a GET request.
+      # @option method_params [Hash] :post POST data in case you want to send a POST request.
+      # @return [Hash] parsed JSON response from the server
+      # @api semipublic
+      def send_request(path, method_params = {})
+        @connection.send_request path, method_params
+      end
+    end
+  end
+end

data/lib/ashikawa-core/document.rb

@@ -0,0 +1,37 @@
+module Ashikawa
+  module Core
+    # Represents a certain Document within a certain Collection
+    class Document
+      # The ID of the document including the Collection prefix
+      # 
+      # @return [String]
+      # @api public
+      # @example Get the ID for a Document
+      #   document = Ashikawa::Core::Document.new "1234567/2345678", "3456789"
+      #   document.id # => "1234567/2345678"
+      attr_reader :id
+      
+      # The current revision of the document
+      # 
+      # @return [String]
+      # @api public
+      # @example Get the Revision for a Document
+      #   document = Ashikawa::Core::Document.new "1234567/2345678", "3456789"
+      #   document.revision # => "3456789"
+      attr_reader :revision
+      
+      # Initialize a Document with an ID and revision
+      # 
+      # @param [String] id The complete ID including the Collection prefix
+      # @param [String] revision
+      # @api public
+      # @example The Document 2345678 in the Collection 1234567 in revision 3456789
+      #   document = Ashikawa::Core::Document.new "1234567/2345678", "3456789"
+      def initialize(id, revision)
+        @id = id
+        @revision = revision
+      end
+      
+    end
+  end
+end

data/lib/ashikawa-core/version.rb

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

data/spec/fixtures/collections/4588.json

@@ -0,0 +1,8 @@
+{
+	"name": "example_1",
+	"waitForSync": true,
+	"id": 4588,
+	"status": 3,
+	"error": false,
+	"code": 200
+}

data/spec/fixtures/collections/4590-properties.json

@@ -0,0 +1,9 @@
+{
+	"name": "new_collection",
+	"waitForSync": true,
+	"id": 4590,
+	"status": 3,
+	"error": false,
+	"code": 200,
+	"count": 54
+}

data/spec/fixtures/collections/4590.json

@@ -0,0 +1,8 @@
+{
+	"name": "new_collection",
+	"waitForSync": true,
+	"id": 4590,
+	"status": 3,
+	"error": false,
+	"code": 200
+}

data/spec/fixtures/collections/73482-figures.json

@@ -0,0 +1,23 @@
+{
+  "name": "UnitTestsCollectionBasics",
+  "code": 200,
+  "figures": {
+    "datafiles": {
+      "count": 1
+    },
+    "alive": {
+      "size": 0,
+      "count": 0
+    },
+    "dead": {
+      "size": 2384,
+      "count": 149
+    }
+  },
+  "waitForSync": true,
+  "id": 73482,
+  "journalSize": 134217728,
+  "count": 0,
+  "status": 3,
+  "error": false
+}

data/spec/fixtures/collections/all.json

@@ -0,0 +1,32 @@
+{
+	"collections": [
+		{
+			"name": "example_1",
+			"waitForSync": true,
+			"id": 4588,
+			"status": 3
+		},
+		{
+			"name": "example_2",
+			"waitForSync": true,
+			"id": 4589,
+			"status": 3
+		}
+	],
+	"code": 200,
+	"error": false,
+	"names":{
+		"example_1": {
+			"name": "example_1",
+			"waitForSync": true,
+			"id": 4588,
+			"status": 3
+		},
+		"example_2": {
+			"name": "example_2",
+			"waitForSync": true,
+			"id": 4589,
+			"status": 3
+		}
+	}
+}

data/spec/fixtures/collections/not_found.json

@@ -0,0 +1,6 @@
+{
+	"error": true,
+	"code": 404,
+	"errorNum": 1203,
+	"errorMessage": "unknown collection 'new_collection'"
+}

data/spec/fixtures/documents/4590-333.json

@@ -0,0 +1,5 @@
+{
+  "_rev": 28411694,
+  "_id": "4590/333",
+  "Hello": "World"
+}

data/spec/fixtures/simple-queries/all.json

@@ -0,0 +1,4 @@
+[
+	{ "_id" : "12345/57463", "_rev" : 57463, "hello" : "world" },
+	{ "_id" : "12346/3872", "_rev" : 3872, "key" : "value" }
+]

data/spec/fixtures/simple-queries/all_limit.json

@@ -0,0 +1,3 @@
+[
+	{ "_id" : "12345/57463", "_rev" : 57463, "hello" : "world" }
+]

data/spec/fixtures/simple-queries/all_skip.json

@@ -0,0 +1,3 @@
+[
+	{ "_id" : "12346/3872", "_rev" : 3872, "key" : "value" }
+]

data/spec/fixtures/simple-queries/example.json

@@ -0,0 +1,3 @@
+[
+	{ "_id" : "12345/57463", "_rev" : 57463, "hello" : "world" }
+]

data/spec/fixtures/simple-queries/near.json

@@ -0,0 +1,5 @@
+[
+	{ "_id" : "12345/57463", "_rev" : 57463, "name" : "world/0/0", "loc" : [0, 0] },
+	{ "_id" : "12346/2938", "_rev" : 2938, "name" : "world/0/10", "loc" : [0, 10] },
+	{ "_id" : "12347/23737", "_rev" : 23737, "name" : "world/-10/0", "loc" : [-10, 0] }
+]

data/spec/fixtures/simple-queries/within.json

@@ -0,0 +1,3 @@
+[
+	{ "_id" : "12345/57463", "_rev" : 57463, "name" : "world/0/0", "loc" : [0, 0] }
+]

data/spec/integration/basic_spec.rb

@@ -0,0 +1,167 @@
+require 'integration/spec_helper'
+
+describe "Basics" do
+  subject { "http://localhost:8529" }
+
+  it "should have booted up an ArangoDB instance" do
+    expect { JSON.parse RestClient.get(subject) }.to raise_error(RestClient::NotImplemented)
+  end
+
+  describe "initialized database" do
+    subject { Ashikawa::Core::Database.new "http://localhost:8529" }
+
+    it "should do what the README describes" do
+      subject["my_collection"]
+      subject["my_collection"].name = "new_name"
+      subject["new_name"].delete
+    end
+
+    it "should create and delete collections" do
+      subject.collections.should ==[]
+      subject["collection_1"]
+      subject["collection_2"]
+      subject["collection_3"]
+      subject.collections.length.should == 3
+      subject["collection_3"].delete
+      subject.collections.length.should == 2
+    end
+
+    it "should be possible to change the name of a collection" do
+      my_collection = subject["test_collection"]
+      my_collection.name.should == "test_collection"
+      my_collection.name = "my_new_name"
+      my_collection.name.should == "my_new_name"
+    end
+
+    it "should be possible to find a collection by ID" do  
+      my_collection = subject["test_collection"]
+      subject[my_collection.id].name.should == "test_collection"
+    end
+
+    it "should be possible to load and unload collections" do  
+      my_collection = subject["test_collection"]
+      my_collection.loaded?.should be_true
+      my_collection.unload
+      my_id = my_collection.id
+      my_collection = subject[my_id]
+      subject[my_id].loaded?.should be_false
+    end
+
+    it "should be possible to get figures" do  
+      my_collection = subject["test_collection"]
+      my_collection.figure(:datafiles_count).class.should == Fixnum
+      my_collection.figure(:alive_size).class.should == Fixnum
+      my_collection.figure(:alive_count).class.should == Fixnum
+      my_collection.figure(:dead_size).class.should == Fixnum
+      my_collection.figure(:dead_count).class.should == Fixnum
+    end
+
+    it "should change and receive information about waiting for sync" do
+      my_collection = subject["my_collection"]
+      my_collection.wait_for_sync?.should be_false
+      my_collection.wait_for_sync = true
+      my_collection.wait_for_sync?.should be_true
+    end
+
+    it "should be possible to get information about the number of documents" do
+      pending("`<<` not implemented yet")
+      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.length.should == 2
+      empty_collection.truncate!
+      empty_collection.length.should == 0
+    end
+
+    it "should return all documents of a collection" do
+      pending("`<<` not implemented yet")
+      empty_collection = subject["empty_collection"]
+      empty_collection << { name: "testname", age: 27}
+      empty_collection.all.first["name"].should == "testname"
+    end
+
+    it "should be possible to limit and skip results" do
+      pending("`<<` not implemented yet")
+      empty_collection = subject["empty_collection"]
+      empty_collection.truncate!
+
+      empty_collection << { name: "test1"}
+      empty_collection << { name: "test2"}
+      empty_collection << { name: "test3"}
+
+      empty_collection.all(limit: 2).length.should == 2
+      empty_collection.all(skip: 2).length.should == 1
+    end
+
+
+    it "should be possible to access and create documents from a collection" do
+      collection = subject["documenttests"]
+
+      pending("`create` not implemented yet")
+      document = collection.create name: "The Dude", bowling: true
+      document_id = document.id
+      collection[document_id]["name"].should == "The Dude"
+
+      collection[document_id] = { name: "Other Dude", bowling: true }
+      collection[document_id]["name"].should == "Other Dude"
+    end
+
+    describe "geolocation" do
+      before :each do
+        @places = subject['geo_collection']
+        @places.truncate!
+
+        pending("`<<` not implemented yet")
+        @places << { name: "cologne", latitude: 50.948045, longitude: 6.961212 }
+        @places << { name: "san francisco", latitude: -122.395899, longitude: 37.793621 }
+      end
+
+      it "should be possible to query documents near a certain location" do
+        near_places = @places.near latitude: -122.395898, longitude: 37.793622
+        near_places.length.should == 1
+        near_places.first.name.should == "san francisco"
+      end
+
+      it "should be possible to query documents within a certain range" do
+        near_places = @places.within latitude: 50.948040, longitude: 6.961210, radius: 2
+        near_places.length.should == 1
+        near_places.first.name.should == "cologne"
+      end
+    end
+
+    describe "created document" do
+      before :each do
+        pending("`create` not implemented yet")
+        @collection = subject["documenttests"]
+        @document = @collection.create name: "The Dude"
+        @document_id = @document.id
+      end
+
+      it "should be possible to manipulate documents and save them" do
+        @document = @collection[document_id]
+        @document["name"] = "Jeffrey Lebowski"
+        @document["name"].should == "Jeffrey Lebowski"
+        @collection[@document_id].should == "The Dude"
+        @document.save
+        @collection[@document_id]["name"].should == "Jeffrey Lebowski"
+      end
+
+      it "should be possible to delete a document" do
+        @collection = subject["documenttests"]
+        @document = @collection.create name: "The Dude"
+        @document_id = @document.id
+        @collection[@document_id].delete
+        expect { @collection[@document_id] }.to raise_exception Ashikawa::DocumentNotFoundException
+      end
+    end
+
+    it "should be possible to query documents by example" do
+      collection = subject["documenttests"]
+
+      pending("`<<` not implemented yet")
+      collection << { name: "Random Collection" }
+      collection.by_example("name" => "Random Collection").length.should == 1
+    end
+  end
+end