ashikawa-core 0.5.1 → 0.6.0

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

@@ -0,0 +1,15 @@
+module Ashikawa
+  module Core
+    # This Exception is thrown when a document was requested from
+    # the server that does not exist.
+    class CollectionNotFoundException < RuntimeError
+      # String representation of the exception
+      #
+      # @return String
+      # @api private
+      def to_s
+        "You requested a collection from the server that does not exist"
+      end
+    end
+  end
+end

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

@@ -3,6 +3,10 @@ module Ashikawa
     # This Exception is thrown when a document was requested from
     # the server that does not exist.
     class DocumentNotFoundException < RuntimeError
+      # String representation of the exception
+      #
+      # @return String
+      # @api private
       def to_s
         "You requested a document from the server that does not exist"
       end

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

@@ -0,0 +1,15 @@
+module Ashikawa
+  module Core
+    # This Exception is thrown when an index was requested from
+    # the server that does not exist.
+    class IndexNotFoundException < RuntimeError
+      # String representation of the exception
+      #
+      # @return String
+      # @api private
+      def to_s
+        "You requested an index from the server that does not exist"
+      end
+    end
+  end
+end

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

@@ -3,6 +3,10 @@ module Ashikawa
     # This Exception is thrown when a Query object should execute a simple query
     # but no collection was provided upon creation
     class NoCollectionProvidedException < RuntimeError
+      # String representation of the exception
+      #
+      # @return String
+      # @api private
       def to_s
         "A simple query can't be executed by a Query object without a collection"
       end

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

@@ -0,0 +1,15 @@
+module Ashikawa
+  module Core
+    # This Exception is thrown when you request
+    # a path from the server which is not known
+    class UnknownPath < RuntimeError
+      # String representation of the exception
+      #
+      # @return String
+      # @api private
+      def to_s
+        "The path is unknown"
+      end
+    end
+  end
+end

data/lib/ashikawa-core/figure.rb

@@ -0,0 +1,73 @@
+module Ashikawa
+  module Core
+    # Wrapper around figures of a collection
+    class Figure
+      # Create a wrapper around given figures
+      #
+      # @param [Hash] raw_figure
+      # @api public
+      # @example Create a new figure from a raw figure
+      #   figure = Ashikawa::Core::Figure.new(raw_figure)
+      def initialize(raw_figure)
+        @datafiles = raw_figure["datafiles"]
+        @alive = raw_figure["alive"]
+        @dead = raw_figure["dead"]
+      end
+
+      # The number of active datafiles
+      #
+      # @return Fixnum
+      # @api public
+      # @example Get the number of datafiles
+      #   figure = Ashikawa::Core::Figure.new(raw_figure)
+      #   figure.datafiles_count #=> 1337
+      def datafiles_count
+        @datafiles["count"]
+      end
+
+      # The total size in bytes used by all living documents
+      #
+      # @return Fixnum
+      # @api public
+      # @example Get the size of all living documents in bytes
+      #   figure = Ashikawa::Core::Figure.new(raw_figure)
+      #   figure.alive_size #=> 1337
+      def alive_size
+        @alive["size"]
+      end
+
+      # The number of living documents
+      #
+      # @return Fixnum
+      # @api public
+      # @example Get the number of living documents
+      #   figure = Ashikawa::Core::Figure.new(raw_figure)
+      #   figure.alive_count #=> 1337
+      def alive_count
+        @alive["count"]
+      end
+
+      # The total size in bytes used by all dead documents
+      #
+      # @return Fixnum
+      # @api public
+      # @example Get the size of all dead documents in bytes
+      #   figure = Ashikawa::Core::Figure.new(raw_figure)
+      #   figure.dead_size #=> 1337
+      def dead_size
+        @dead["size"]
+      end
+
+      # The number of dead documents
+      #
+      # @return Fixnum
+      # @api public
+      # @example Get the number of dead documents
+      #   figure = Ashikawa::Core::Figure.new(raw_figure)
+      #   figure.dead_count #=> 1337
+      def dead_count
+        @dead["count"]
+      end
+    end
+  end
+end

data/lib/ashikawa-core/index.rb

@@ -1,25 +1,37 @@
 module Ashikawa
   module Core
-    # Represents an index on a certain collection
+    # An index on a certain collection
     class Index
       # The fields the index is defined on as symbols
       # @return [Array<Symbol>]
       # @api public
+      # @example Get the fields the index is set on
+      #   index = Ashikawa::Core::Index.new(collection, raw_index)
+      #   index.fields #=> [:name]
       attr_reader :on
 
       # The type of index as a symbol
       # @return [Symbol]
       # @api public
+      # @example Get the type of the index
+      #   index = Ashikawa::Core::Index.new(collection, raw_index)
+      #   index.type #=> :skiplist
       attr_reader :type
 
       # Is the unique constraint set?
       # @return [Boolean]
       # @api public
+      # @example Get the fields the index is set on
+      #   index = Ashikawa::Core::Index.new(collection, raw_index)
+      #   index.unique #=> false
       attr_reader :unique
 
       # The id of the index
       # @return [Int]
       # @api public
+      # @example Get the id of this index
+      #   index = Ashikawa::Core::Index.new(collection, raw_index)
+      #   index.id #=> 4567
       attr_reader :id
 
       # Create a new Index
@@ -27,20 +39,26 @@ module Ashikawa
       # @param [Collection] collection The collection the index is defined on
       # @param [Hash] raw_index The JSON representation of the index
       # @return [Index]
-      # @api
+      # @api public
+      # @example Create a new index from the raw representation
+      #   index = Ashikawa::Core::Index.new(collection, raw_index)
       def initialize(collection, raw_index)
         @collection = collection
-        @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"
+        @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
       #
+      # @return [Hash] parsed JSON response from the server
       # @api public
+      # @example Remove this index from the collection
+      #   index = Ashikawa::Core::Index.new(collection, raw_index)
+      #   index.delete
       def delete
-        @collection.send_request("index/#{@collection.id}/#{@id}", delete: {})
+        @collection.send_request("index/#{@collection.id}/#{@id}", :delete => {})
       end
     end
   end

data/lib/ashikawa-core/query.rb

@@ -2,6 +2,8 @@ require 'ashikawa-core/cursor'
 require 'ashikawa-core/document'
 require 'ashikawa-core/exceptions/no_collection_provided'
 require 'forwardable'
+require 'backports'
+require 'rest-client'
 
 module Ashikawa
   module Core
@@ -10,12 +12,16 @@ module Ashikawa
       extend Forwardable
 
       # Delegate sending requests to the connection
-      delegate send_request: :@connection
+      def_delegator :@connection, :send_request
 
       # Initializes a Query
       #
       # @param [Collection, Database] connection
       # @return [Query]
+      # @api public
+      # @example Create a new query object
+      #   collection = Ashikawa::Core::Collection.new(database, raw_collection)
+      #   query = Ashikawa::Core::Query.new(collection)
       def initialize(connection)
         @connection = connection
       end
@@ -29,12 +35,12 @@ module Ashikawa
       # @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 = Ashikawa::Core::Query.new(collection)
       #   query.all # => #<Cursor id=33>
       def all(options={})
-        simple_query_request "/simple/all",
+        simple_query_request("/simple/all",
           options,
-          [:limit, :skip]
+          [:limit, :skip])
       end
 
       # Looks for documents in a collection which match the given criteria
@@ -47,12 +53,12 @@ module Ashikawa
       # @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>
+      #   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]
+        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
@@ -62,12 +68,12 @@ module Ashikawa
       # @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">
+      #   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 = simple_query_request("/simple/first-example",
+          { :example => example },
+          [:example])
         response.first
       end
 
@@ -83,12 +89,12 @@ module Ashikawa
       # @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
+      #   query = Ashikawa::Core::Query.new(collection)
+      #   query.near(:latitude => 37.331693, :longitude => -122.030468)
       def near(options={})
-        simple_query_request "/simple/near",
+        simple_query_request("/simple/near",
           options,
-          [:latitude, :longitude, :distance, :skip, :limit, :geo]
+          [:latitude, :longitude, :distance, :skip, :limit, :geo])
       end
 
       # Looks for documents in a collection within a radius
@@ -104,12 +110,12 @@ module Ashikawa
       # @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
+      #   query = Ashikawa::Core::Query.new(collection)
+      #   query.within(:latitude => 37.331693, :longitude => -122.030468, :radius => 100)
       def within(options={})
-        simple_query_request "/simple/within",
+        simple_query_request("/simple/within",
           options,
-          [:latitude, :longitude, :radius, :distance, :skip, :limit, :geo]
+          [:latitude, :longitude, :radius, :distance, :skip, :limit, :geo])
       end
 
       # Looks for documents in a collection with an attribute between two values
@@ -124,12 +130,12 @@ module Ashikawa
       # @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
+      #   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",
+        simple_query_request("/simple/range",
           options,
-          [:attribute, :left, :right, :closed, :limit, :skip]
+          [:attribute, :left, :right, :closed, :limit, :skip])
       end
 
       # Send an AQL query to the database
@@ -140,12 +146,12 @@ module Ashikawa
       # @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>
+      #   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]
+        post_request("/cursor",
+          options.merge({ :query => query }),
+          [:query, :count, :batch_size])
       end
 
       # Test if an AQL query is valid
@@ -154,14 +160,12 @@ module Ashikawa
       # @return [Boolean]
       # @api public
       # @example Validate an AQL query
-      #   query = Ashikawa::Core::Query.new collection
-      #   query.valid? "FOR u IN users LIMIT 2" # => true
+      #   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
+          !!post_request("/query", { :query => query })
+      rescue RestClient::BadRequest
+        false
       end
 
       private
@@ -179,7 +183,7 @@ module Ashikawa
       # @return [collection]
       # @api private
       def collection
-        raise NoCollectionProvidedException unless @connection.respond_to? :database
+        raise NoCollectionProvidedException unless @connection.respond_to?(:database)
         @connection
       end
 
@@ -190,10 +194,10 @@ module Ashikawa
       # @return [Hash] The filtered Hash
       # @api private
       def allowed_options(options, allowed_keys)
-        options.keep_if { |key, _| allowed_keys.include? key }
+        options.keep_if { |key, _| allowed_keys.include?(key) }
       end
 
-      # Transforms the keys into strings, camelizes them and removes pairs without a value
+      # Transforms the keys into the required format
       #
       # @param [Hash] request_data
       # @return [Hash] Cleaned request data
@@ -208,18 +212,33 @@ module Ashikawa
       #
       # @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
+      # @param [Array<Symbol>] allowed_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 = request_data.merge({ :collection => collection.name })
+        put_request(path,
           request_data,
-          allowed_keys << :collection
+          allowed_keys << :collection)
+      end
+
+      # Perform a wrapped request
+      #
+      # @param [String] path The path for the request
+      # @param [Symbol] request_method The request method to perform
+      # @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 wrapped_request(path, request_method, request_data, allowed_keys)
+        request_data = allowed_options(request_data, allowed_keys) unless allowed_keys.nil?
+        request_data = prepare_request_data(request_data)
+        server_response = send_request(path, { request_method => request_data })
+        Cursor.new(database, server_response)
       end
 
-      # Perform a put request
+      # Perform a wrapped put request
       #
       # @param [String] path The path for the request
       # @param [Hash] request_data The data send to the database
@@ -227,13 +246,10 @@ module Ashikawa
       # @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
+        wrapped_request(path, :put, request_data, allowed_keys)
       end
 
-      # Perform a post request
+      # Perform a wrapped post request
       #
       # @param [String] path The path for the request
       # @param [Hash] request_data The data send to the database
@@ -241,10 +257,7 @@ module Ashikawa
       # @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
+        wrapped_request(path, :post, request_data, allowed_keys)
       end
     end
   end