ashikawa-core 0.7.2 → 0.8.0

data/config/yardstick.yml

@@ -1,2 +1,2 @@
 ---
-threshold: 98.2
+threshold: 100

data/lib/ashikawa-core/collection.rb

@@ -5,7 +5,9 @@ require "ashikawa-core/cursor"
 require "ashikawa-core/query"
 require "ashikawa-core/status"
 require "ashikawa-core/figure"
+require "ashikawa-core/key_options"
 require "forwardable"
+require "equalizer"
 
 module Ashikawa
   module Core
@@ -13,6 +15,8 @@ module Ashikawa
     class Collection
       extend Forwardable
 
+      include Equalizer.new(:id, :name, :content_type, :database)
+
       CONTENT_TYPES = {
         2 => :document,
         3 => :edge
@@ -205,6 +209,17 @@ module Ashikawa
         send_information_to_server(:properties, :waitForSync, new_value)
       end
 
+      # Get information about the type of keys of this collection
+      #
+      # @return [KeyOptions]
+      # @api public
+      # @example Check if this collection has autoincrementing keys
+      #   collection = Ashikawa::Core::Collection.new(database, raw_collection)
+      #   collection.key_options.type # => "autoincrement"
+      def key_options
+        KeyOptions.new(get_information_from_server(:properties, :keyOptions))
+      end
+
       # Returns the number of documents in the collection
       #
       # @return [Fixnum] Number of documents
@@ -326,29 +341,56 @@ module Ashikawa
         send_command_to_server(:truncate)
       end
 
-      # Fetch a certain document by its ID
+      # Fetch a certain document by its key
       #
-      # @param [Integer] document_id the id of the document
+      # @param [Integer] document_key the key of the document
       # @raise [DocumentNotFoundException] If the requested document was not found
       # @return Document
       # @api public
-      # @example Fetch the document with the ID 12345
-      #   document = collection[12345]
-      def [](document_id)
-        response = send_request_for_content_id(document_id)
+      # @example Fetch the document with the key 12345
+      #   document = collection.fetch(12345)
+      def fetch(document_key)
+        response = send_request_for_content_key(document_key)
         @content_class.new(@database, response)
       end
 
-      # Replace a document by its ID
+      # Fetch a certain document by its key, return nil if the document does not exist
       #
-      # @param [Integer] document_id the id of the document
+      # @param [Integer] document_key the id of the document
+      # @return Document
+      # @api public
+      # @example Fetch the document with the key 12345
+      #   document = collection[12345]
+      def [](document_key)
+        fetch(document_key)
+      rescue DocumentNotFoundException
+        nil
+      end
+
+      # Replace a document by its key
+      #
+      # @param [Integer] document_key the key of the document
       # @param [Hash] raw_document the data you want to replace it with
       # @return [Hash] parsed JSON response from the server
       # @api public
-      # @example Replace the document with the ID 12345
-      #   collection[12345] = document
-      def []=(document_id, raw_document)
-        send_request_for_content_id(document_id, :put => raw_document)
+      # @example Replace the document with the key 12345
+      #   collection.replace(12345, document)
+      def replace(document_key, raw_document)
+        send_request_for_content_key(document_key, :put => raw_document)
+      end
+
+      # Replace a document by its key
+      #
+      # @param [Integer] document_key the key of the document
+      # @param [Hash] raw_document the data you want to replace it with
+      # @return [Hash] parsed JSON response from the server
+      # @api public
+      # @deprecated Use {#replace} instead.
+      # @example Replace the document with the key 12345
+      #   collection.replace(12345, document)
+      def []=(document_key, raw_document)
+        warn "`[]=` is deprecated, please use `replace`"
+        replace(document_key, raw_document)
       end
 
       # Create a new document with given attributes
@@ -361,10 +403,21 @@ module Ashikawa
       def create_document(attributes)
         raise "Can't create a document in an edge collection" if @content_type == :edge
         response = send_request_for_content(:post => attributes)
-        Document.new(@database, response)
+        Document.new(@database, response).refresh!
       end
 
-      alias :<< :create_document
+      # Create a new document with given attributes
+      #
+      # @param [Hash] attributes
+      # @return [Document] The created document
+      # @api public
+      # @deprecated Use {#create_document} instead.
+      # @example Create a new document from raw data
+      #   collection << attributes
+      def <<(attributes)
+        warn "`<<` is deprecated, please use `create_document`"
+        create_document(attributes)
+      end
 
       # Create a new edge between two documents with certain attributes
       #
@@ -378,7 +431,7 @@ module Ashikawa
       def create_edge(from, to, attributes)
         raise "Can't create an edge in a document collection" if @content_type == :document
         response = send_request("edge?collection=#{@id}&from=#{from.id}&to=#{to.id}", :post => attributes)
-        Edge.new(@database, response)
+        Edge.new(@database, response).refresh!
       end
 
       # Add an index to the collection
@@ -408,8 +461,8 @@ module Ashikawa
       #   people = database['people']
       #   people.index(1244) #=> #<Index: id=1244...>
       def index(id)
-        server_response = send_request("index/#{@name}/#{id}")
-        Index.new(self, server_response)
+        response = send_request("index/#{@name}/#{id}")
+        Index.new(self, response)
       end
 
       # Get all indices
@@ -486,7 +539,7 @@ module Ashikawa
       #
       # @return [String] Response from the server
       # @api private
-      def send_request_for_this_collection(path, method={})
+      def send_request_for_this_collection(path, method = {})
         send_request("collection/#{id}/#{path}", method)
       end
 
@@ -503,14 +556,14 @@ module Ashikawa
         self
       end
 
-      # Send a request for the content with the given id
+      # Send a request for the content with the given key
       #
       # @param [Integer] document_id The id of the document
       # @param [Hash] opts The options for the request
       # @return [Hash] parsed JSON response from the server
       # @api private
-      def send_request_for_content_id(document_id, opts = {})
-        send_request("#{@content_type}/#{@id}/#{document_id}", opts)
+      def send_request_for_content_key(document_key, opts = {})
+        send_request("#{@content_type}/#{@id}/#{document_key}", opts)
       end
 
       # Send a request for the content of this collection

data/lib/ashikawa-core/configuration.rb

@@ -0,0 +1,26 @@
+module Ashikawa
+  module Core
+    # Configuration of Ashikawa::Core
+    class Configuration < Struct.new(:url, :connection, :logger, :adapter)
+      # The URL of the database instance
+      # @api private
+      # @return String
+      attr_accessor :url
+
+      # The Connection object
+      # @api private
+      # @return Connection
+      attr_accessor :connection
+
+      # The logger instance
+      # @api private
+      # @return Object
+      attr_accessor :logger
+
+      # The HTTP adapter instance
+      # @api private
+      # @return Object
+      attr_accessor :adapter
+    end
+  end
+end

data/lib/ashikawa-core/connection.rb

@@ -2,6 +2,7 @@ require "forwardable"
 require "faraday"
 require "null_logger"
 require "uri"
+require "equalizer"
 require "ashikawa-core/request_preprocessor"
 require "ashikawa-core/response_preprocessor"
 
@@ -11,6 +12,8 @@ module Ashikawa
     class Connection
       extend Forwardable
 
+      include Equalizer.new(:host, :scheme, :port)
+
       # The host part of the connection
       #
       # @!method host
@@ -55,7 +58,7 @@ module Ashikawa
         @connection = Faraday.new("#{api_string}/_api") do |connection|
           connection.request  :ashikawa_request,  logger
           connection.response :ashikawa_response, logger
-          connection.adapter *adapter
+          connection.adapter(*adapter)
         end
       end
 
@@ -113,7 +116,7 @@ module Ashikawa
       # @return [Symbol] The HTTP verb used
       # @api private
       def http_verb(params)
-        [:post, :put, :delete].find { |method_name|
+        [:post, :put, :delete].detect { |method_name|
           params.has_key?(method_name)
         } || :get
       end

data/lib/ashikawa-core/cursor.rb

@@ -1,4 +1,6 @@
 require 'ashikawa-core/document'
+require 'ashikawa-core/edge'
+require 'equalizer'
 
 module Ashikawa
   module Core
@@ -7,6 +9,8 @@ module Ashikawa
     class Cursor
       include Enumerable
 
+      include Equalizer.new(:id)
+
       # The ID of the cursor
       # @return [String]
       # @api public
@@ -54,7 +58,7 @@ module Ashikawa
 
         begin
           @current.each do |raw_document|
-            yield Document.new(@database, raw_document)
+            yield parse_raw_document(raw_document)
           end
         end while next_batch
         nil
@@ -72,6 +76,28 @@ module Ashikawa
 
       private
 
+      # Parse a raw document and return a Document or Edge for it
+      #
+      # @param [Hash] raw_document
+      # @return Document | Edge
+      # @api private
+      def parse_raw_document(raw_document)
+        detect_document_class_for(raw_document).new(@database, raw_document)
+      end
+
+      # Detect if a raw document is a document or edge and return the class
+      #
+      # @param [Hash] raw_document
+      # @return class
+      # @api private
+      def detect_document_class_for(raw_document)
+        if raw_document.has_key?("_from") && raw_document.has_key?("_to")
+          Edge
+        else
+          Document
+        end
+      end
+
       # Pull the raw data from the cursor into this object
       #
       # @param [Hash] raw_cursor
@@ -80,11 +106,7 @@ module Ashikawa
       def parse_raw_cursor(raw_cursor)
         @id       = raw_cursor['id']
         @has_more = raw_cursor['hasMore']
-        if raw_cursor['result']
-          parse_documents_cursor(raw_cursor)
-        elsif raw_cursor['document']
-          parse_document_cursor(raw_cursor)
-        end
+        parse_documents_cursor(raw_cursor)
         self
       end
 
@@ -98,16 +120,6 @@ module Ashikawa
         @length  = raw_cursor['count'].to_i if raw_cursor.has_key?('count')
       end
 
-      # Parse the cursor for a single document
-      #
-      # @param [Hash] raw_cursor
-      # @return self
-      # @api private
-      def parse_document_cursor(raw_cursor)
-        @current = [raw_cursor['document']]
-        @length  = 1
-      end
-
       # Get a new batch from the server
       #
       # @return [Boolean] Is there a next batch?

data/lib/ashikawa-core/database.rb

@@ -2,13 +2,13 @@ require "ashikawa-core/exceptions/client_error/resource_not_found/collection_not
 require "ashikawa-core/collection"
 require "ashikawa-core/connection"
 require "ashikawa-core/cursor"
+require "ashikawa-core/configuration"
+require "ashikawa-core/transaction"
 require "forwardable"
+require "equalizer"
 
 module Ashikawa
   module Core
-    # Configuration of Ashikawa::Core
-    Configuration = Struct.new(:url, :connection, :logger, :adapter)
-
     # An ArangoDB database
     class Database
       COLLECTION_TYPES = {
@@ -18,6 +18,8 @@ module Ashikawa
 
       extend Forwardable
 
+      include Equalizer.new(:host, :port, :scheme)
+
       # Delegate sending requests to the connection
       def_delegator :@connection, :send_request
       def_delegator :@connection, :host
@@ -43,13 +45,13 @@ module Ashikawa
       #     config.adapter = my_adapter
       #     config.logger = my_logger
       #   end
-      def initialize()
+      def initialize
         configuration = Ashikawa::Core::Configuration.new
         yield(configuration)
         @connection = configuration.connection || setup_new_connection(configuration.url, configuration.logger, configuration.adapter)
       end
 
-      # Returns a list of all collections defined in the database
+      # Returns a list of all non-system collections defined in the database
       #
       # @return [Array<Collection>]
       # @api public
@@ -59,8 +61,18 @@ module Ashikawa
       #   database["b"]
       #   database.collections # => [ #<Collection name="a">, #<Collection name="b">]
       def collections
-        response = send_request("collection")
-        response["collections"].map { |collection| Ashikawa::Core::Collection.new(self, collection) }
+        all_collections_where { |collection| !collection["name"].start_with?("_") }
+      end
+
+      # Returns a list of all system 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.system_collections # => [ #<Collection name="_a">, #<Collection name="_b">]
+      def system_collections
+        all_collections_where { |collection| collection["name"].start_with?("_") }
       end
 
       # Create a Collection based on name
@@ -73,11 +85,8 @@ module Ashikawa
       # @example Create a new, volatile collection
       #   database = Ashikawa::Core::Database.new("http://localhost:8529")
       #   database.create_collection("a", :isVolatile => true) # => #<Collection name="a">
-      def create_collection(collection_identifier, opts={})
-        params = { :name => collection_identifier }
-        params[:isVolatile] = true if opts[:is_volatile] == true
-        params[:type] = COLLECTION_TYPES[opts[:content_type]] if opts.has_key?(:content_type)
-        response = send_request("collection", :post => params)
+      def create_collection(collection_identifier, opts = {})
+        response = send_request("collection", :post => translate_params(collection_identifier, opts))
         Ashikawa::Core::Collection.new(self, response)
       end
 
@@ -115,6 +124,22 @@ module Ashikawa
         Query.new(self)
       end
 
+      # Create a new Transaction for this database
+      #
+      # @param [String] action The JS action you want to execute
+      # @options collections [Array<String>] :read The collections you want to read from
+      # @options collections [Array<String>] :write The collections you want to write to
+      # @return [Object] The result of the transaction
+      # @api public
+      # @example Create a new Transaction
+      #   transaction = database.create_transaction("function () { return 5; }", :read => ["collection_1"])
+      #   transaction.execute #=> 5
+      def create_transaction(action, collections)
+        Ashikawa::Core::Transaction.new(self, action, collections)
+      end
+
+      private
+
       # Setup the connection object
       #
       # @param [String] url
@@ -129,6 +154,58 @@ module Ashikawa
           :adapter => adapter
         })
       end
+
+      # Parse a raw collection
+      #
+      # @param [Array] raw_collections
+      # @return [Array]
+      # @api private
+      def parse_raw_collections(raw_collections)
+        raw_collections.map { |collection|
+          Ashikawa::Core::Collection.new(self, collection)
+        }
+      end
+
+      # Translate the key options into the required format
+      #
+      # @param [Hash] key_options
+      # @return [Hash]
+      # @api private
+      def translate_key_options(key_options)
+        {
+          :type => key_options[:type].to_s,
+          :offset => key_options[:offset],
+          :increment => key_options[:increment],
+          :allowUserKeys => key_options[:allow_user_keys]
+        }
+      end
+
+      # Translate the params into the required format
+      #
+      # @param [String] collection_identifier
+      # @param [Hash] opts
+      # @return [Hash]
+      # @api private
+      def translate_params(collection_identifier, opts)
+        params = { :name => collection_identifier }
+        params[:isVolatile] = true if opts[:is_volatile] == true
+        params[:type] = COLLECTION_TYPES[opts[:content_type]] if opts.has_key?(:content_type)
+        params[:keyOptions] = translate_key_options(opts[:key_options]) if opts.has_key?(:key_options)
+        params
+      end
+
+      # Get all collections that fulfill a certain criteria
+      #
+      # @yield [raw_collection] Yields the raw collections so you can decide which to keep
+      # @yieldparam [raw_collection] A raw collection
+      # @yieldreturn [Boolean] Should the collection be kept
+      # @return [Array<Collection>]
+      # @api private
+      def all_collections_where(&block)
+        raw_collections = send_request("collection")["collections"]
+        raw_collections.keep_if(&block)
+        parse_raw_collections(raw_collections)
+      end
     end
   end
 end