ashikawa-core 0.4.1 → 0.5.1

data/lib/ashikawa-core/document.rb

@@ -29,16 +29,19 @@ module Ashikawa
       # @api public
       def initialize(database, raw_document)
         @database = database
-        @is_persistent = raw_document.has_key?('_id') and raw_document.has_key?('rev')
-
-        if @is_persistent
-          @collection_id, @id = raw_document['_id'].split('/').map { |id| id.to_i }
-          @revision = raw_document['_rev'].to_i
-        end
-
+        @collection_id, @id = raw_document['_id'].split('/').map { |id| id.to_i } unless raw_document['_id'].nil?
+        @revision = raw_document['_rev'].to_i unless raw_document['_rev'].nil?
         @content = raw_document.delete_if { |key, value| key[0] == "_" }
       end
 
+      # Raises an exception if the document is not persisted
+      #
+      # @raise [DocumentNotFoundException]
+      # @api semi-public
+      def check_if_persisted!
+        raise DocumentNotFoundException if @id.nil?
+      end
+
       # Get the value of an attribute of the document
       #
       # @param [String] attribute_name
@@ -52,7 +55,7 @@ module Ashikawa
       #
       # @api public
       def delete
-        raise DocumentNotFoundException unless @is_persistent
+        check_if_persisted!
         @database.send_request "document/#{@collection_id}/#{@id}", delete: {}
       end
 
@@ -62,7 +65,7 @@ module Ashikawa
       # @param [Object] value
       # @api public
       def []=(attribute_name, value)
-        raise DocumentNotFoundException unless @is_persistent
+        check_if_persisted!
         @content[attribute_name] = value
       end
 
@@ -78,7 +81,7 @@ module Ashikawa
       #
       # @api public
       def save()
-        raise DocumentNotFoundException unless @is_persistent
+        check_if_persisted!
         @database.send_request "document/#{@collection_id}/#{@id}", put: @content
       end
     end

data/lib/ashikawa-core/exceptions/document_not_found.rb

@@ -1,8 +1,11 @@
 module Ashikawa
   module Core
-    # This Exception is thrown, when a document was requested from
+    # This Exception is thrown when a document was requested from
     # the server that does not exist.
     class DocumentNotFoundException < RuntimeError
+      def to_s
+        "You requested a document from the server that does not exist"
+      end
     end
   end
 end

data/lib/ashikawa-core/exceptions/no_collection_provided.rb

@@ -0,0 +1,11 @@
+module Ashikawa
+  module Core
+    # This Exception is thrown when a Query object should execute a simple query
+    # but no collection was provided upon creation
+    class NoCollectionProvidedException < RuntimeError
+      def to_s
+        "A simple query can't be executed by a Query object without a collection"
+      end
+    end
+  end
+end

data/lib/ashikawa-core/index.rb

@@ -25,15 +25,15 @@ module Ashikawa
       # Create a new Index
       #
       # @param [Collection] collection The collection the index is defined on
-      # @param [Hash] raw_data The JSON representation of the index
+      # @param [Hash] raw_index The JSON representation of the index
       # @return [Index]
       # @api
-      def initialize(collection, raw_data)
+      def initialize(collection, raw_index)
         @collection = collection
-        @id = raw_data["id"].split("/")[1].to_i if raw_data["id"]
-        @on = raw_data["fields"].map { |field| field.to_sym } if raw_data.has_key? "fields"
-        @type = raw_data["type"].to_sym if raw_data.has_key? "type"
-        @unique = raw_data["unique"] if raw_data.has_key? "unique"
+        @id = raw_index["id"].split("/")[1].to_i if raw_index.has_key? "id"
+        @on = raw_index["fields"].map { |field| field.to_sym } if raw_index.has_key? "fields"
+        @type = raw_index["type"].to_sym if raw_index.has_key? "type"
+        @unique = raw_index["unique"] if raw_index.has_key? "unique"
       end
 
       # Remove the index from the collection

data/lib/ashikawa-core/query.rb

@@ -0,0 +1,251 @@
+require 'ashikawa-core/cursor'
+require 'ashikawa-core/document'
+require 'ashikawa-core/exceptions/no_collection_provided'
+require 'forwardable'
+
+module Ashikawa
+  module Core
+    # Formulate a Query on a collection or on a database
+    class Query
+      extend Forwardable
+
+      # Delegate sending requests to the connection
+      delegate send_request: :@connection
+
+      # Initializes a Query
+      #
+      # @param [Collection, Database] connection
+      # @return [Query]
+      def initialize(connection)
+        @connection = connection
+      end
+
+      # Retrieves all documents for a collection
+      #
+      # @note It is advised to NOT use this method due to possible HUGE data amounts requested
+      # @option options [Integer] :limit limit the maximum number of queried and returned elements.
+      # @option options [Integer] :skip skip the first <n> documents of the query.
+      # @return [Cursor]
+      # @raise [NoCollectionProvidedException] If you provided a database, no collection
+      # @api public
+      # @example Get an array with all documents
+      #   query = Ashikawa::Core::Query.new collection
+      #   query.all # => #<Cursor id=33>
+      def all(options={})
+        simple_query_request "/simple/all",
+          options,
+          [:limit, :skip]
+      end
+
+      # Looks for documents in a collection which match the given criteria
+      #
+      # @option example [Hash] a Hash with data matching the documents you are looking for.
+      # @option options [Hash] a Hash with additional settings for the query.
+      # @option options [Integer] :limit limit the maximum number of queried and returned elements.
+      # @option options [Integer] :skip skip the first <n> documents of the query.
+      # @return [Cursor]
+      # @raise [NoCollectionProvidedException] If you provided a database, no collection
+      # @api public
+      # @example Find all documents in a collection that are red
+      #   query = Ashikawa::Core::Query.new collection
+      #   query.by_example { "color" => "red" }, :options => { :limit => 1 } # => #<Cursor id=2444>
+      def by_example(example={}, options={})
+        simple_query_request "/simple/by-example",
+          { example: example }.merge(options),
+          [:limit, :skip, :example]
+      end
+
+      # Looks for one document in a collection which matches the given criteria
+      #
+      # @param [Hash] example a Hash with data matching the document you are looking for.
+      # @return [Document]
+      # @raise [NoCollectionProvidedException] If you provided a database, no collection
+      # @api public
+      # @example Find one document in a collection that is red
+      #   query = Ashikawa::Core::Query.new collection
+      #   query.first_example { "color" => "red"} # => #<Document id=2444 color="red">
+      def first_example(example = {})
+        response = simple_query_request "/simple/first-example",
+          { example: example },
+          [:example]
+        response.first
+      end
+
+      # Looks for documents in a collection based on location
+      #
+      # @option options [Integer] :latitude Latitude location for your search.
+      # @option options [Integer] :longitude Longitude location for your search.
+      # @option options [Integer] :skip The documents to skip in the query.
+      # @option options [Integer] :distance If given, the attribute key used to store the distance.
+      # @option options [Integer] :limit The maximal amount of documents to return (default: 100).
+      # @option options [Integer] :geo If given, the identifier of the geo-index to use.
+      # @return [Cursor]
+      # @raise [NoCollectionProvidedException] If you provided a database, no collection
+      # @api public
+      # @example Find all documents at Infinite Loop
+      #   query = Ashikawa::Core::Query.new collection
+      #   query.near latitude: 37.331693, longitude: -122.030468
+      def near(options={})
+        simple_query_request "/simple/near",
+          options,
+          [:latitude, :longitude, :distance, :skip, :limit, :geo]
+      end
+
+      # Looks for documents in a collection within a radius
+      #
+      # @option options [Integer] :latitude Latitude location for your search.
+      # @option options [Integer] :longitude Longitude location for your search.
+      # @option options [Integer] :radius Radius around the given location you want to search in.
+      # @option options [Integer] :skip The documents to skip in the query.
+      # @option options [Integer] :distance If given, the attribute key used to store the distance.
+      # @option options [Integer] :limit The maximal amount of documents to return (default: 100).
+      # @option options [Integer] :geo If given, the identifier of the geo-index to use.
+      # @return [Cursor]
+      # @api public
+      # @raise [NoCollectionProvidedException] If you provided a database, no collection
+      # @example Find all documents within a radius of 100 to Infinite Loop
+      #   query = Ashikawa::Core::Query.new collection
+      #   query.within latitude: 37.331693, longitude: -122.030468, radius: 100
+      def within(options={})
+        simple_query_request "/simple/within",
+          options,
+          [:latitude, :longitude, :radius, :distance, :skip, :limit, :geo]
+      end
+
+      # Looks for documents in a collection with an attribute between two values
+      #
+      # @option options [Integer] :attribute The attribute path to check.
+      # @option options [Integer] :left The lower bound
+      # @option options [Integer] :right The upper bound
+      # @option options [Integer] :closed If true, use intervall including left and right, otherwise exclude right, but include left.
+      # @option options [Integer] :skip The documents to skip in the query (optional).
+      # @option options [Integer] :limit The maximal amount of documents to return (optional).
+      # @return [Cursor]
+      # @raise [NoCollectionProvidedException] If you provided a database, no collection
+      # @api public
+      # @example Find all documents within a radius of 100 to Infinite Loop
+      #   query = Ashikawa::Core::Query.new collection
+      #   query.within latitude: 37.331693, longitude: -122.030468, radius: 100
+      def in_range(options={})
+        simple_query_request "/simple/range",
+          options,
+          [:attribute, :left, :right, :closed, :limit, :skip]
+      end
+
+      # Send an AQL query to the database
+      #
+      # @param [String] query
+      # @option options [Integer] :count Should the number of results be counted?
+      # @option options [Integer] :batch_size Set the number of results returned at once
+      # @return [Cursor]
+      # @api public
+      # @example Send an AQL query to the database
+      #   query = Ashikawa::Core::Query.new collection
+      #   query.execute "FOR u IN users LIMIT 2" # => #<Cursor id=33>
+      def execute(query, options = {})
+        post_request "/cursor",
+          options.merge({ query: query }),
+          [:query, :count, :batch_size]
+      end
+
+      # Test if an AQL query is valid
+      #
+      # @param [String] query
+      # @return [Boolean]
+      # @api public
+      # @example Validate an AQL query
+      #   query = Ashikawa::Core::Query.new collection
+      #   query.valid? "FOR u IN users LIMIT 2" # => true
+      def valid?(query)
+        begin
+          !!post_request("/query", { query: query })
+        rescue RestClient::BadRequest
+          false
+        end
+      end
+
+      private
+
+      # The database object
+      #
+      # @return [Database]
+      # @api private
+      def database
+        @connection.respond_to?(:database) ? @connection.database : @connection
+      end
+
+      # The collection object
+      #
+      # @return [collection]
+      # @api private
+      def collection
+        raise NoCollectionProvidedException unless @connection.respond_to? :database
+        @connection
+      end
+
+      # Removes the keys that are not allowed from an object
+      #
+      # @param [Hash] options
+      # @param [Array<Symbol>] allowed_keys
+      # @return [Hash] The filtered Hash
+      # @api private
+      def allowed_options(options, allowed_keys)
+        options.keep_if { |key, _| allowed_keys.include? key }
+      end
+
+      # Transforms the keys into strings, camelizes them and removes pairs without a value
+      #
+      # @param [Hash] request_data
+      # @return [Hash] Cleaned request data
+      # @api private
+      def prepare_request_data(request_data)
+        Hash[request_data.map { |key, value|
+          [key.to_s.gsub(/_(.)/) { $1.upcase }, value]
+        }].reject { |_, value| value.nil? }
+      end
+
+      # Send a simple query to the server
+      #
+      # @param [String] path The path for the request
+      # @param [Hash] request_data The data send to the database
+      # @param [Array<Symbol>] keys The keys allowed for this request
+      # @return [String] Server response
+      # @raise [NoCollectionProvidedException] If you provided a database, no collection
+      # @api private
+      def simple_query_request(path, request_data, allowed_keys)
+        request_data = request_data.merge({ collection: collection.name })
+        put_request path,
+          request_data,
+          allowed_keys << :collection
+      end
+
+      # Perform a put request
+      #
+      # @param [String] path The path for the request
+      # @param [Hash] request_data The data send to the database
+      # @param [Array] allowed_keys Keys allowed in request_data, if nil: All keys are allowed
+      # @return [Cursor]
+      # @api private
+      def put_request(path, request_data, allowed_keys = nil)
+        request_data = allowed_options request_data, allowed_keys unless allowed_keys.nil?
+        request_data = prepare_request_data request_data
+        server_response = send_request path, :put => request_data
+        Cursor.new database, server_response
+      end
+
+      # Perform a post request
+      #
+      # @param [String] path The path for the request
+      # @param [Hash] request_data The data send to the database
+      # @param [Array] allowed_keys Keys allowed in request_data, if nil: All keys are allowed
+      # @return [Cursor]
+      # @api private
+      def post_request(path, request_data, allowed_keys = nil)
+        request_data = allowed_options request_data, allowed_keys unless allowed_keys.nil?
+        request_data = prepare_request_data request_data
+        server_response = send_request path, :post => request_data
+        Cursor.new database, server_response
+      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.4.1"
+    VERSION = "0.5.1"
   end
 end

data/spec/{integration → acceptance}/arango_helper.rb

@@ -1,7 +1,7 @@
 RSpec.configure do |config|
   raise "Could not find arangod. Please install it or check if it is in your path." if `which arangod` == ""
 
-  database_directory = "/tmp/ashikawa-integration"
+  database_directory = "/tmp/ashikawa-acceptance"
   arango_process = false
 
   config.before(:suite) do

data/spec/{integration → acceptance}/basic_spec.rb

@@ -1,11 +1,11 @@
-require 'integration/spec_helper'
+require 'acceptance/spec_helper'
 
 describe "Basics" do
   subject { ARANGO_HOST }
 
-  it "should have booted up an ArangoDB instance" do
-    expect { RestClient.get(subject) }.to_not raise_error
-  end
+  # it "should have booted up an ArangoDB instance" do
+    # expect { RestClient.get(subject) }.to_not raise_error
+  # end
 
   describe "initialized database" do
     subject { Ashikawa::Core::Database.new ARANGO_HOST }

data/spec/{integration → acceptance}/index_spec.rb

@@ -1,4 +1,4 @@
-require 'integration/spec_helper'
+require 'acceptance/spec_helper'
 
 describe "Indices" do
   let(:database) { Ashikawa::Core::Database.new ARANGO_HOST }

data/spec/acceptance/query_spec.rb

@@ -0,0 +1,90 @@
+require 'acceptance/spec_helper'
+
+describe "Queries" do
+  let(:database) { Ashikawa::Core::Database.new ARANGO_HOST }
+  let(:collection) { database["my_collection"] }
+
+  describe "AQL query via the database" do
+    it "should return the documents" do
+      collection << { "name" => "Jeff Lebowski",    "bowling" => true }
+      collection << { "name" => "Walter Sobchak",   "bowling" => true }
+      collection << { "name" => "Donny Kerabatsos", "bowling" => true }
+      collection << { "name" => "Jeffrey Lebowski", "bowling" => false }
+
+      query = "FOR u IN my_collection FILTER u.bowling == true RETURN u"
+      results = database.query.execute query, batch_size: 2, count: true
+
+      results.length.should == 3
+      results = results.map { |person| person["name"] }
+      results.should     include "Jeff Lebowski"
+      results.should_not include "Jeffrey Lebowski"
+    end
+
+    it "should be possible to validate" do
+      valid_query = "FOR u IN my_collection FILTER u.bowling == true RETURN u"
+      database.query.valid?(valid_query).should be_true
+
+      invalid_query = "FOR u IN my_collection FILTER u.bowling == true"
+      database.query.valid?(invalid_query).should be_false
+    end
+  end
+
+  describe "simple query via collection object" do
+    subject { collection }
+    before(:each) { subject.truncate! }
+
+    it "should return all documents of a collection" do
+      subject << { 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.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" }
+      result = subject.query.by_example name: "Random Document"
+      result.length.should == 1
+    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 }
+      end
+
+      it "should be possible to query documents near a certain location" do
+        found_places = subject.query.near latitude: 50, longitude: 6
+        found_places.first["name"].should == "cologne"
+      end
+
+      it "should be possible to query documents within a certain range" do
+        found_places = subject.query.within latitude: 50.948040, longitude: 6.961210, radius: 2
+        found_places.length.should == 1
+        found_places.first["name"].should == "cologne"
+      end
+    end
+
+    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 }
+      end
+
+      it "should be possible to query documents for numbers in a certain range" do
+        found_people = subject.query.in_range attribute: "age", left: 20, right: 30, closed: true
+        found_people.length.should == 1
+        found_people.first["name"].should == "Anne"
+      end
+    end
+  end
+end

data/spec/{integration_auth → acceptance_auth}/arango_helper.rb

@@ -1,7 +1,7 @@
 RSpec.configure do |config|
   raise "Could not find arangod. Please install it or check if it is in your path." if `which arangod` == ""
 
-  database_directory = "/tmp/ashikawa-integration-auth"
+  database_directory = "/tmp/ashikawa-acceptance-auth"
   arango_process = false
 
   config.before(:suite) do

data/spec/{integration_auth → acceptance_auth}/auth_spec.rb

@@ -1,4 +1,4 @@
-require 'integration/spec_helper'
+require 'acceptance_auth/spec_helper'
 
 describe "authenticated database" do
   subject { ARANGO_HOST }

data/spec/fixtures/query/valid.json

@@ -0,0 +1,5 @@
+{
+  "error": false,
+  "bindVars": [],
+  "code": 200
+}

data/spec/setup/arangodb.sh

@@ -0,0 +1,68 @@
+#!/bin/bash
+
+DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+cd $DIR
+
+#VERSION=1.0.2
+VERSION=1.1.beta1
+
+NAME=ArangoDB-$VERSION
+
+if [ ! -d "$DIR/$NAME" ]; then
+  # download ArangoDB
+  wget http://www.arangodb.org/travisCI/$NAME.tar.gz
+  tar zxf $NAME.tar.gz
+fi
+
+
+PID=$(echo $PPID)
+TMP_DIR="/tmp/arangodb.$PID"
+PID_FILE="/tmp/arangodb.$PID.pid"
+ARANGODB_DIR="$DIR/$NAME"
+UPDATE_SCRIPT="${ARANGODB_DIR}/js/server/arango-upgrade.js"
+
+# create database directory
+mkdir ${TMP_DIR}
+
+# check for update script
+echo "looking for: $UPDATE_SCRIPT"
+if [ -f "$UPDATE_SCRIPT" ] ; then
+  # version 1.1
+  ${ARANGODB_DIR}/bin/arangod \
+    --database.directory ${TMP_DIR}  \
+    --configuration none  \
+    --server.endpoint tcp://127.0.0.1:8529 \
+    --javascript.startup-directory ${ARANGODB_DIR}/js \
+    --javascript.modules-path ${ARANGODB_DIR}/js/server/modules:${ARANGODB_DIR}/js/common/modules \
+    --javascript.script "$UPDATE_SCRIPT"
+
+  ${ARANGODB_DIR}/bin/arangod \
+    --database.directory ${TMP_DIR}  \
+    --configuration none  \
+    --server.endpoint tcp://127.0.0.1:8529 \
+    --javascript.startup-directory ${ARANGODB_DIR}/js \
+    --javascript.modules-path ${ARANGODB_DIR}/js/server/modules:${ARANGODB_DIR}/js/common/modules \
+    --javascript.action-directory ${ARANGODB_DIR}/js/actions/system  \
+    --database.maximal-journal-size 1048576  \
+    --server.disable-admin-interface true \
+    --server.disable-authentication true \
+    --javascript.gc-interval 1 &
+else
+  # version 1.0
+  ${ARANGODB_DIR}/bin/arangod ${TMP_DIR}  \
+    --configuration none  \
+    --pid-file ${PID_FILE} \
+    --javascript.startup-directory ${ARANGODB_DIR}/js \
+    --javascript.modules-path ${ARANGODB_DIR}/js/server/modules:${ARANGODB_DIR}/js/common/modules \
+    --javascript.action-directory ${ARANGODB_DIR}/js/actions/system  \
+    --database.maximal-journal-size 1000000  \
+    --javascript.gc-interval 1 &
+fi
+
+echo "Waiting until ArangoDB is ready on port 8529"
+while [[ -z `curl -s 'http://127.0.0.1:8529/_api/version' ` ]] ; do
+  echo -n "."
+  sleep 2s
+done
+
+echo "ArangoDB is up"