ashikawa-core 0.1

data/.gitignore

@@ -0,0 +1,8 @@
+.DS_Store
+.yardoc
+doc
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+report/*

data/.rvmrc

@@ -0,0 +1 @@
+rvm use @$(basename `pwd`) --create

data/.travis.yml

@@ -0,0 +1,13 @@
+language: ruby
+rvm:
+  - 1.9.2
+  - 1.9.3
+  - rbx-19mode
+  - jruby-19mode
+  - ruby-head
+  - jruby-head
+matrix:
+  allow_failures:
+    - rvm: ruby-head
+    - rvm: jruby-head
+script: "rake ci"

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in ashikawa-core.gemspec
+gemspec

data/README.md

@@ -0,0 +1,63 @@
+# Ashikawa Core
+
+[![Build Status](https://secure.travis-ci.org/triAGENS/ashikawa-core.png?branch=master)](http://travis-ci.org/triAGENS/ashikawa-core)
+
+Ashikawa Core is a Wrapper around the ArangoDB Rest API. It provides low level access and will be used in different ArangoDB ODMs.
+
+## How to use it
+
+For a detailed description of Ashikawa::Core please refer to the [documentation](http://rdoc.info/github/triAGENS/ashikawa-core/master/frames). An example:
+
+```ruby
+database = Ashikawa::Core::Database.new "http://localhost:8529"
+
+database["my_collection"] # => Returns the collection my_collection – creates it, if it doesn't exist
+database["my_collection"].name = "new_name"
+database["new_name"].delete
+```
+
+## How to get started developing
+
+Getting started is easy, just follow these steps.
+
+### In a nutshell
+
+* Clone the project.
+* `cd` into the folder and run `bundle` 
+* `rake` and see all tests passing (you need to have ArangoDB installed for that)
+* Happy coding!
+
+### Detailed description
+
+Make sure you are running Ruby 1.9.x (or JRuby/Rubinius in 1.9 mode) and clone the latest snapshot into a directory of your choice. Also make sure ArangoDB is installed and accessible via `arangod` (for example by installing it via `brew install arangodb`).
+
+We encourage you to use [rvm](https://rvm.io/). If you do so, a gemset for the project is created upon changing into the directory. If you do not use `rvm` nothing special will happen in this case. Don't worry about it.
+
+Change into the project directory. Run `bundle` to get all dependencies (do a `gem install bundler` before if you don't have bundler installed).
+
+Now you can run `rake` to see all tests passing (hopefully). Happy coding!
+
+You can also start up yard for documentation: `rake yard:server`
+
+### Continuous Integration
+
+Our tests are run on Travis CI, the build status is displayed above. **Please note** that it only runs the unit tests and not the integration tests, because that would require ArangoDB to be installed on the Travis CI boxes. *Therefore green doesn't neccessarily mean green* (which is unfortunate).
+
+## Contributing
+
+When you want to write code for the project, please follow these guidelines:
+
+1. Claim the ticket: Tell us that you want to work on a certain ticket, we will assign it to you (We don't want two people to work on the same thing ;) )
+2. Write an Integration Test: Describe what you want to do (our integration tests touch the database)
+3. Implement it: Write a unit test, check that it fails, make the test pass – repeat (our unit tests don't touch the database)
+4. Write Documentation for it: Check the compatibility with our rules via *yardstick*
+5. Check with `rake` that everything is fine and send the Pull Request :)
+
+## Documentation
+
+We want `Ashikawa::Core` to be a solid foundation for all Ruby Libraries connecting to ArangoDB. Therefore we want an excellent documentation. We created two rake tasks:
+
+* `rake yard:report`: Measure docs in lib/**/*.rb with yardstick
+* `rake yard:verify`: Verify that yardstick coverage is 100%
+
+The Yardstick coverage will be checked by our CI. Please make sure that the coverage is always at 100%.

data/Rakefile

@@ -0,0 +1,66 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require "rspec"
+require "rspec/core/rake_task"
+# require 'yardstick/rake/measurement'
+# require 'yardstick/rake/verify'
+
+
+namespace :spec do
+  desc "Run the integration tests. Requires ArangoDB."
+  RSpec::Core::RakeTask.new(:integration) do |spec|
+    spec.pattern = "spec/integration/*_spec.rb"
+  end
+  
+  desc "Run the unit tests"
+  RSpec::Core::RakeTask.new(:unit) do |spec|
+    spec.pattern = "spec/unit/*_spec.rb"
+  end
+  
+  desc "Run all tests. Requires ArangoDB"
+  task :all => [:integration, :unit]
+end
+
+desc "check if gems are up to date"
+task :dependencies do
+  dependency_status = `bundle outdated`
+  if dependency_status.include? "up to date"
+    puts "Dependencies up to date."
+  else
+    puts dependency_status
+    exit(1)
+  end
+end
+
+namespace :yard do
+  # Yardstick::Rake::Measurement.new(:report) do |measurement|
+  #   measurement.output = 'report/measurement.txt'
+  # end
+  
+  # Yardstick::Rake::Verify.new(:verify) do |verify|
+  #   verify.threshold = 100
+  # end
+
+  desc "generate the documentation"
+  task :generate do
+    `yard`
+  end
+  
+  desc "start the documentation server on port 8808"
+  task :server do
+    `yard server --reload`
+  end
+  
+  desc "get statistics on the yard documentation"
+  task :stats do
+    `yard stats`
+  end
+end
+
+desc "Run Unit Tests and verify documentation - no ArangoDB required"
+# task :ci => ["spec:unit", "yard:verify", "dependencies"]
+task :ci => ["spec:unit", "dependencies"]
+
+desc "Run all tests and verify documentation - ArangoDB required"
+# task :default => ["spec:all", "yard:verify", "dependencies"]
+task :default => ["spec:all", "dependencies"]

data/ashikawa-core.gemspec

@@ -0,0 +1,40 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "ashikawa-core/version"
+
+Gem::Specification.new do |gem|
+  gem.name        = "ashikawa-core"
+  gem.version     = Ashikawa::Core::VERSION
+  gem.authors     = ["moonglum", "EinLama"]
+  gem.email       = ["me@moonglum.net", "tobias.eilert@me.com"]
+  gem.homepage    = ""
+  gem.summary     = "Ashikawa Core is a Wrapper around the ArangoDB Rest API"
+  gem.description = "Ashikawa Core is a Wrapper around the ArangoDB Rest API. It provides low level access and will be used in different ArangoDB ODMs."
+  
+  gem.required_ruby_version = '>= 1.9.2'
+  gem.requirements << "ArangoDB"
+  
+  gem.rubyforge_project = "ashikawa-core"
+
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.require_paths = ["lib"]
+
+  # Runtime Dependencies
+  gem.add_dependency "rest-client", "~> 1.6.7"
+  
+  # Runtime Dependencies (JRuby only)
+  if defined? PLATFORM and PLATFORM == 'java'
+    gem.add_dependency "json", "~> 1.6.6"
+    gem.add_dependency "jruby-openssl", "~> 0.7.6.1"
+  end
+  
+  # Development Dependencies
+  gem.add_development_dependency "rake", "~> 0.9.2.2"
+  gem.add_development_dependency "rspec", "~> 2.11.0"
+  gem.add_development_dependency "yard", "~> 0.8.2.1"
+  gem.add_development_dependency "webmock", "~> 1.8.9"
+  # gem.add_development_dependency "yardstick", "~> 0.6.0"
+  gem.add_development_dependency "redcarpet", "~> 2.1.1"
+end

data/lib/ashikawa-core.rb

@@ -0,0 +1,12 @@
+require "ashikawa-core/collection"
+require "ashikawa-core/connection"
+require "ashikawa-core/database"
+require "ashikawa-core/document"
+require "ashikawa-core/version"
+
+# Ashikawa is a project dedicated to connect Ruby and ArangoDB
+module Ashikawa
+  # Ashikawa::Core is a wrapper around the ArangoDB REST interface
+  module Core
+  end
+end

data/lib/ashikawa-core/collection.rb

@@ -0,0 +1,524 @@
+require "ashikawa-core/document"
+
+module Ashikawa
+  module Core
+    # Represents a certain Collection within the Database
+    class Collection
+      # The name of the collection, must be unique
+      # 
+      # @return [String]
+      # @api public
+      # @example Change the name of a collection
+      #   database = Ashikawa::Core::Database.new "http://localhost:8529"
+      #   raw_collection = {
+      #     "name" => "example_1",
+      #     "waitForSync" => true,
+      #     "id" => 4588,
+      #     "status" => 3,
+      #     "error" => false,
+      #     "code" => 200
+      #   }
+      #   collection = Ashikawa::Core::Collection.new database, raw_collection
+      #   collection.name # => "example_1"
+      #   collection.name = "example_2"
+      #   collection.name # => "example_2"
+      attr_reader :name
+      
+      # The ID of the collection. Is set by the database and unique
+      # 
+      # @return [Fixnum]
+      # @api public
+      # @example Get the id of the collection
+      #   database = Ashikawa::Core::Database.new "http://localhost:8529"
+      #   raw_collection = {
+      #     "name" => "example_1",
+      #     "waitForSync" => true,
+      #     "id" => 4588,
+      #     "status" => 3,
+      #     "error" => false,
+      #     "code" => 200
+      #   }
+      #   collection = Ashikawa::Core::Collection.new database, raw_collection
+      #   collection.id #=> 4588
+      attr_reader :id
+      
+      # Create a new Collection object with a name and an optional ID
+      # 
+      # @param [Database] database The database the connection belongs to
+      # @param [Hash] raw_collection The raw collection returned from the server
+      # @api public
+      # @example Create a Collection object from scratch
+      #   database = Ashikawa::Core::Database.new "http://localhost:8529"
+      #   raw_collection = {
+      #     "name" => "example_1",
+      #     "waitForSync" => true,
+      #     "id" => 4588,
+      #     "status" => 3,
+      #     "error" => false,
+      #     "code" => 200
+      #   }
+      #   collection = Ashikawa::Core::Collection.new database, raw_collection
+      def initialize(database, raw_collection)
+        @database = database
+        @name = raw_collection['name'] if raw_collection.has_key? 'name'
+        @id  = raw_collection['id'].to_i if raw_collection.has_key? 'id'
+        @status = raw_collection['status'].to_i if raw_collection.has_key? 'status'
+      end
+      
+      # Change the name of the collection
+      # 
+      # @param [String] new_name New Name
+      # @return [String] New Name
+      # @api public
+      # @example Change the name of a collection
+      #   database = Ashikawa::Core::Database.new "http://localhost:8529"
+      #   raw_collection = {
+      #     "name" => "example_1",
+      #     "waitForSync" => true,
+      #     "id" => 4588,
+      #     "status" => 3,
+      #     "error" => false,
+      #     "code" => 200
+      #   }
+      #   collection = Ashikawa::Core::Collection.new database, raw_collection
+      #   collection.name # => "example_1"
+      #   collection.name = "example_2"
+      #   collection.name # => "example_2"
+      def name=(new_name)
+        send_request_for_this_collection "/rename", put: { "name" => new_name }
+        @name = new_name
+      end
+      
+      # Checks if the collection is new born
+      # 
+      # @return [Boolean]
+      # @api public
+      # @example Is the collection new born?
+      #   database = Ashikawa::Core::Database.new "http://localhost:8529"
+      #   raw_collection = {
+      #     "name" => "example_1",
+      #     "waitForSync" => true,
+      #     "id" => 4588,
+      #     "status" => 3,
+      #     "error" => false,
+      #     "code" => 200
+      #   }
+      #   collection = Ashikawa::Core::Collection.new database, raw_collection
+      #   collection.new_born? #=> false
+      def new_born?
+        @status == 1
+      end
+      
+      # Checks if the collection is unloaded
+      # 
+      # @return [Boolean]
+      # @api public
+      # @example Is the collection unloaded?
+      #   database = Ashikawa::Core::Database.new "http://localhost:8529"
+      #   raw_collection = {
+      #     "name" => "example_1",
+      #     "waitForSync" => true,
+      #     "id" => 4588,
+      #     "status" => 3,
+      #     "error" => false,
+      #     "code" => 200
+      #   }
+      #   collection = Ashikawa::Core::Collection.new database, raw_collection
+      #   collection.unloaded? #=> false
+      def unloaded?
+        @status == 2
+      end
+      
+      # Checks if the collection is loaded
+      # 
+      # @return [Boolean]
+      # @api public
+      # @example Is the collection loaded?
+      #   database = Ashikawa::Core::Database.new "http://localhost:8529"
+      #   raw_collection = {
+      #     "name" => "example_1",
+      #     "waitForSync" => true,
+      #     "id" => 4588,
+      #     "status" => 3,
+      #     "error" => false,
+      #     "code" => 200
+      #   }
+      #   collection = Ashikawa::Core::Collection.new database, raw_collection
+      #   collection.loaded? #=> true
+      def loaded?
+        @status == 3
+      end
+      
+      # Checks if the collection is in the process of being unloaded
+      # 
+      # @return [Boolean]
+      # @api public
+      # @example Is the collection unloaded?
+      #   database = Ashikawa::Core::Database.new "http://localhost:8529"
+      #   raw_collection = {
+      #     "name" => "example_1",
+      #     "waitForSync" => true,
+      #     "id" => 4588,
+      #     "status" => 3,
+      #     "error" => false,
+      #     "code" => 200
+      #   }
+      #   collection = Ashikawa::Core::Collection.new database, raw_collection
+      #   collection.being_unloaded? #=> false
+      def being_unloaded?
+        @status == 4
+      end
+      
+      # Checks if the collection is corrupted
+      # 
+      # @return [Boolean]
+      # @api public
+      # @example Is the collection corrupted?
+      #   database = Ashikawa::Core::Database.new "http://localhost:8529"
+      #   raw_collection = {
+      #     "name" => "example_1",
+      #     "waitForSync" => true,
+      #     "id" => 4588,
+      #     "status" => 3,
+      #     "error" => false,
+      #     "code" => 200
+      #   }
+      #   collection = Ashikawa::Core::Collection.new database, raw_collection
+      #   collection.corrupted? #=> false
+      def corrupted?
+        @status > 5
+      end
+      
+      # Does the document wait until the data has been synchronised to disk?
+      # 
+      # @return [Boolean]
+      # @api public
+      # @example Does the collection wait for file synchronization?
+      #   database = Ashikawa::Core::Database.new "http://localhost:8529"
+      #   raw_collection = {
+      #     "name" => "example_1",
+      #     "waitForSync" => true,
+      #     "id" => 4588,
+      #     "status" => 3,
+      #     "error" => false,
+      #     "code" => 200
+      #   }
+      #   collection = Ashikawa::Core::Collection.new database, raw_collection
+      #   collection.wait_for_sync? #=> false
+      def wait_for_sync?
+        server_response = send_request_for_this_collection "/properties"
+        server_response["waitForSync"]
+      end
+      
+      # Change if the document will wait until the data has been synchronised to disk
+      # 
+      # @return [String] Response from the server
+      # @api public
+      # @example Tell the collection to wait for file synchronization
+      #   database = Ashikawa::Core::Database.new "http://localhost:8529"
+      #   raw_collection = {
+      #     "name" => "example_1",
+      #     "waitForSync" => true,
+      #     "id" => 4588,
+      #     "status" => 3,
+      #     "error" => false,
+      #     "code" => 200
+      #   }
+      #   collection = Ashikawa::Core::Collection.new database, raw_collection
+      #   collection.wait_for_sync = true
+      def wait_for_sync=(new_value)
+        server_response = send_request_for_this_collection "/properties", put: { "waitForSync" => new_value }
+      end
+      
+      # Returns the number of documents in the collection
+      # 
+      # @return [Fixnum] Number of documents
+      # @api public
+      # @example How many documents are in the collection?
+      #   database = Ashikawa::Core::Database.new "http://localhost:8529"
+      #   raw_collection = {
+      #     "name" => "example_1",
+      #     "waitForSync" => true,
+      #     "id" => 4588,
+      #     "status" => 3,
+      #     "error" => false,
+      #     "code" => 200
+      #   }
+      #   collection = Ashikawa::Core::Collection.new database, raw_collection
+      #   collection.length # => 0
+      def length
+        server_response = send_request_for_this_collection "/count"
+        server_response["count"]
+      end
+      
+      # Return a figure for the collection
+      # 
+      # @param [Symbol] figure_type The figure you want to know:
+      #     * :datafiles_count - the number of active datafiles
+      #     * :alive_size - the total size in bytes used by all living documents
+      #     * :alive_count - the number of living documents
+      #     * :dead_size - the total size in bytes used by all dead documents
+      #     * :dead_count - the number of dead documents
+      # @return [Fixnum] The figure you requested
+      # @api public
+      # @example Get the datafile count for a collection
+      #   database = Ashikawa::Core::Database.new "http://localhost:8529"
+      #   raw_collection = {
+      #     "name" => "example_1",
+      #     "waitForSync" => true,
+      #     "id" => 4588,
+      #     "status" => 3,
+      #     "error" => false,
+      #     "code" => 200
+      #   }
+      #   collection = Ashikawa::Core::Collection.new database, raw_collection
+      #   collection.figure :datafiles_count #=> 0
+      def figure(figure_type)
+        server_response = send_request_for_this_collection "/figures"
+        
+        figure_area, figure_name = figure_type.to_s.split "_"
+        server_response["figures"][figure_area][figure_name]
+      end
+      
+      # Deletes the collection
+      # 
+      # @return [String] Response from the server
+      # @api public
+      # @example Delete a collection
+      #   database = Ashikawa::Core::Database.new "http://localhost:8529"
+      #   raw_collection = {
+      #     "name" => "example_1",
+      #     "waitForSync" => true,
+      #     "id" => 4588,
+      #     "status" => 3,
+      #     "error" => false,
+      #     "code" => 200
+      #   }
+      #   collection = Ashikawa::Core::Collection.new database, raw_collection
+      #   collection.delete
+      def delete
+        send_request_for_this_collection "", delete: {}
+      end
+      
+      # Load the collection into memory
+      # 
+      # @return [String] Response from the server
+      # @api public
+      # @example Load a collection into memory
+      #   database = Ashikawa::Core::Database.new "http://localhost:8529"
+      #   raw_collection = {
+      #     "name" => "example_1",
+      #     "waitForSync" => true,
+      #     "id" => 4588,
+      #     "status" => 3,
+      #     "error" => false,
+      #     "code" => 200
+      #   }
+      #   collection = Ashikawa::Core::Collection.new database, raw_collection
+      #   collection.load
+      def load
+        send_request_for_this_collection "/load", put: {}
+      end
+      
+      # Load the collection into memory
+      # 
+      # @return [String] Response from the server
+      # @api public
+      # @example Unload a collection into memory
+      #   database = Ashikawa::Core::Database.new "http://localhost:8529"
+      #   raw_collection = {
+      #     "name" => "example_1",
+      #     "waitForSync" => true,
+      #     "id" => 4588,
+      #     "status" => 3,
+      #     "error" => false,
+      #     "code" => 200
+      #   }
+      #   collection = Ashikawa::Core::Collection.new database, raw_collection
+      #   collection.unload
+      def unload
+        send_request_for_this_collection "/unload", put: {}
+      end
+      
+      # Delete all documents from the collection
+      # 
+      # @return [String] Response from the server
+      # @api public
+      # @example Remove all documents from a collection
+      #   database = Ashikawa::Core::Database.new "http://localhost:8529"
+      #   raw_collection = {
+      #     "name" => "example_1",
+      #     "waitForSync" => true,
+      #     "id" => 4588,
+      #     "status" => 3,
+      #     "error" => false,
+      #     "code" => 200
+      #   }
+      #   collection = Ashikawa::Core::Collection.new database, raw_collection
+      #   collection.truncate!
+      def truncate!
+        send_request_for_this_collection "/truncate", put: {}
+      end
+      
+      # Retrieves all documents for this collection
+      # 
+      # @note It is advised to NOT use this method due to possible HUGE data amounts requested
+      # @param [Hash] options Additional options for this 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 [Array<Document>]
+      # @api public
+      # @example Get an array with all documents
+      #   database = Ashikawa::Core::Database.new "http://localhost:8529"
+      #   raw_collection = {
+      #     "name" => "example_1",
+      #     "waitForSync" => true,
+      #     "id" => 4588,
+      #     "status" => 3,
+      #     "error" => false,
+      #     "code" => 200
+      #   }
+      #   collection = Ashikawa::Core::Collection.new database, raw_collection
+      #   collection.all # => [#<Document id=43>]
+      def all(options={})
+        request_data = { "collection" => @name }
+        
+        request_data["limit"] = options[:limit] if options.has_key? :limit
+        request_data["skip"] = options[:skip] if options.has_key? :skip
+        
+        server_response = @database.send_request "/simple/all", :put => request_data
+        
+        documents_from_response(server_response)
+      end
+      
+      # Looks for documents in the collection which match the given criteria
+      # 
+      # @param [Hash] reference_data a Hash with data similar to the documents you are looking for.
+      # @param [Hash] options Additional options for this 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 [Array<Document>]
+      # @api public
+      # @example Find all documents in the collection that are red
+      #   database = Ashikawa::Core::Database.new "http://localhost:8529"
+      #   raw_collection = {
+      #     "name" => "example_1",
+      #     "waitForSync" => true,
+      #     "id" => 4588,
+      #     "status" => 3,
+      #     "error" => false,
+      #     "code" => 200
+      #   }
+      #   collection = Ashikawa::Core::Collection.new database, raw_collection
+      #   collection.by_example { "color" => "red"} # => [#<Document id=2444 color="red">]
+      def by_example(reference_data, options={})
+        request_data = { "collection" => @name, "example" => reference_data }
+        
+        request_data["limit"] = options[:limit] if options.has_key? :limit
+        request_data["skip"] = options[:skip] if options.has_key? :skip
+        
+        server_response = @database.send_request "/simple/by-example", :put => request_data
+        
+        documents_from_response(server_response)
+      end
+      
+      # Looks for documents in the collection based on location
+      #
+      # @param [Hash] options Options for this search.
+      # @option options [Integer] :latitude Latitude location for your search.
+      # @option options [Integer] :longitude Longitude location for your search.
+      # @return [Array<Document>]
+      # @api public
+      # @example Find all documents at Infinite Loop 
+      #   database = Ashikawa::Core::Database.new "http://localhost:8529"
+      #   raw_collection = {
+      #     "name" => "example_1",
+      #     "waitForSync" => true,
+      #     "id" => 4588,
+      #     "status" => 3,
+      #     "error" => false,
+      #     "code" => 200
+      #   }
+      #   collection = Ashikawa::Core::Collection.new database, raw_collection
+      #   collection.near latitude: 37.331693, longitude: -122.030468
+      def near(options={})
+        request_data = { "collection" => @name }
+
+        request_data["latitude"] = options[:latitude] if options.has_key? :latitude
+        request_data["longitude"] = options[:longitude] if options.has_key? :longitude
+
+        server_response = @database.send_request "/simple/near", :put => request_data
+
+        documents_from_response(server_response)
+      end
+
+      # Looks for documents in the collection within a certain radius
+      #
+      # @param [Hash] options Options for this search.
+      # @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.
+      # @return [Array<Document>]
+      # @api public
+      # @example Find all documents within a radius of 100 to Infinite Loop
+      #   database = Ashikawa::Core::Database.new "http://localhost:8529"
+      #   raw_collection = {
+      #     "name" => "example_1",
+      #     "waitForSync" => true,
+      #     "id" => 4588,
+      #     "status" => 3,
+      #     "error" => false,
+      #     "code" => 200
+      #   }
+      #   collection = Ashikawa::Core::Collection.new database, raw_collection
+      #   collection.within latitude: 37.331693, longitude: -122.030468, radius: 100
+      def within(options={})
+        request_data = { "collection" => @name }
+
+        request_data["latitude"] = options[:latitude] if options.has_key? :latitude
+        request_data["longitude"] = options[:longitude] if options.has_key? :longitude
+        request_data["radius"] = options[:radius] if options.has_key? :radius
+
+        server_response = @database.send_request "/simple/within", :put => request_data
+
+        documents_from_response(server_response)
+      end
+
+      # Fetch a certain document by its ID
+      # 
+      # @param [Integer] document_id the id of the document
+      # @return Document
+      # @api public
+      # @example Fetch a document with the ID 12345
+      #   document = collection[12345]
+      def [](document_id)
+        Ashikawa::Core::Document.new "#{@id}/#{document_id}"
+      end
+
+      private
+
+      # Send a request to the server with the name of the collection prepended
+      #
+      # @return [String] Response from the server
+      # @api private
+      def send_request_for_this_collection(path, method={})
+        if method == {}
+          @database.send_request "/collection/#{id}#{path}"
+        else
+          @database.send_request "/collection/#{id}#{path}", method
+        end
+      end
+
+      # Takes JSON returned by the database and collects Documents from the data
+      # 
+      # @param [Array<Hash>] parsed_server_response parsed JSON response from the server. Should contain document-hashes.
+      # @return [Array<Document>]
+      # @api private
+      def documents_from_response(parsed_server_response)
+        parsed_server_response.collect do |document|
+          Ashikawa::Core::Document.new(document["_id"], document["_rev"])
+        end
+      end
+    end
+  end
+end