ashikawa-core 0.8.0 → 0.9.0

data/lib/ashikawa-core/configuration.rb

@@ -1,7 +1,10 @@
+# -*- encoding : utf-8 -*-
+require 'ashikawa-core/connection'
+
 module Ashikawa
   module Core
     # Configuration of Ashikawa::Core
-    class Configuration < Struct.new(:url, :connection, :logger, :adapter)
+    class Configuration
       # The URL of the database instance
       # @api private
       # @return String
@@ -10,7 +13,7 @@ module Ashikawa
       # The Connection object
       # @api private
       # @return Connection
-      attr_accessor :connection
+      attr_writer :connection
 
       # The logger instance
       # @api private
@@ -21,6 +24,42 @@ module Ashikawa
       # @api private
       # @return Object
       attr_accessor :adapter
+
+      # The username for authentication
+      # @api private
+      # @return String
+      attr_accessor :username
+
+      # The password for authentication
+      # @api private
+      # @return String
+      attr_accessor :password
+
+      # The Connection object
+      # @api private
+      # @return Connection
+      def connection
+        @connection = @connection || setup_new_connection
+        @connection.authenticate_with(username: username, password: password) if username && password
+        @connection
+      end
+
+      private
+
+      # Setup the connection object
+      #
+      # @param [String] url
+      # @param [Logger] logger
+      # @param [Adapter] adapter
+      # @return [Connection]
+      # @api private
+      def setup_new_connection
+        raise(ArgumentError, 'Please provide either an url or a connection to setup the database') if url.nil?
+        Ashikawa::Core::Connection.new(url, {
+          logger: logger,
+          adapter: adapter
+        })
+      end
     end
   end
 end

data/lib/ashikawa-core/connection.rb

@@ -1,10 +1,11 @@
-require "forwardable"
-require "faraday"
-require "null_logger"
-require "uri"
-require "equalizer"
-require "ashikawa-core/request_preprocessor"
-require "ashikawa-core/response_preprocessor"
+# -*- encoding : utf-8 -*-
+require 'forwardable'
+require 'faraday'
+require 'null_logger'
+require 'uri'
+require 'equalizer'
+require 'ashikawa-core/request_preprocessor'
+require 'ashikawa-core/response_preprocessor'
 
 module Ashikawa
   module Core
@@ -20,8 +21,8 @@ module Ashikawa
       # @return [String]
       # @api public
       # @example Get the host part of the connection
-      #   connection = Connection.new("http://localhost:8529")
-      #   connection.host # => "localhost"
+      #   connection = Connection.new('http://localhost:8529')
+      #   connection.host # => 'localhost'
       def_delegator :@connection, :host
 
       # The scheme of the connection
@@ -30,8 +31,8 @@ module Ashikawa
       # @return [String]
       # @api public
       # @example Get the scheme of the connection
-      #   connection = Connection.new("http://localhost:8529")
-      #   connection.scheme # => "http"
+      #   connection = Connection.new('http://localhost:8529')
+      #   connection.scheme # => 'http'
       def_delegator :@connection, :scheme
 
       # The port of the connection
@@ -40,7 +41,7 @@ module Ashikawa
       # @return [Fixnum]
       # @api public
       # @example Get the port of the connection
-      #   connection = Connection.new("http://localhost:8529")
+      #   connection = Connection.new('http://localhost:8529')
       #   connection.port # => 8529
       def_delegator :@connection, :port
 
@@ -51,7 +52,7 @@ module Ashikawa
       # @option opts [Object] logger The logger you want to use. Defaults to Null Logger.
       # @api public
       # @example Create a new Connection
-      #  connection = Connection.new("http://localhost:8529")
+      #  connection = Connection.new('http://localhost:8529')
       def initialize(api_string, opts = {})
         logger  = opts[:logger]  || NullLogger.instance
         adapter = opts[:adapter] || Faraday.default_adapter
@@ -84,7 +85,7 @@ module Ashikawa
       # @return [Boolean]
       # @api public
       # @example Is authentication activated for this connection?
-      #   connection = Connection.new("http://localhost:8529")
+      #   connection = Connection.new('http://localhost:8529')
       #   connection.authentication? #=> false
       #   connection.authenticate_with(:username => 'james', :password => 'bond')
       #   connection.authentication? #=> true
@@ -100,7 +101,7 @@ module Ashikawa
       # @raise [ArgumentError] if username or password are missing
       # @api public
       # @example Authenticate with the database for all future requests
-      #   connection = Connection.new("http://localhost:8529")
+      #   connection = Connection.new('http://localhost:8529')
       #   connection.authenticate_with(:username => 'james', :password => 'bond')
       def authenticate_with(options = {})
         raise ArgumentError, 'missing username or password' unless options.key? :username and options.key? :password
@@ -117,7 +118,7 @@ module Ashikawa
       # @api private
       def http_verb(params)
         [:post, :put, :delete].detect { |method_name|
-          params.has_key?(method_name)
+          params.key?(method_name)
         } || :get
       end
     end

data/lib/ashikawa-core/cursor.rb

@@ -1,3 +1,4 @@
+# -*- encoding : utf-8 -*-
 require 'ashikawa-core/document'
 require 'ashikawa-core/edge'
 require 'equalizer'
@@ -16,7 +17,7 @@ module Ashikawa
       # @api public
       # @example Get the id of the cursor
       #   cursor = Ashikawa::Core::Cursor.new(database, raw_cursor)
-      #   cursor.id #=> "1337"
+      #   cursor.id #=> '1337'
       attr_reader :id
 
       # The number of documents
@@ -39,9 +40,9 @@ module Ashikawa
         parse_raw_cursor(raw_cursor)
       end
 
-      # Iterate over the documents found by the cursor
+      # Iterate over the result
       #
-      # @yield [document]
+      # @yield [Object] A Document, An Edge or a Raw Object
       # @return [nil, Enumerator] If no block is given, an Enumerator is returned
       # @api public
       # @example Print all documents
@@ -56,11 +57,12 @@ module Ashikawa
       def each
         return to_enum(__callee__) unless block_given?
 
-        begin
+        loop do
           @current.each do |raw_document|
             yield parse_raw_document(raw_document)
           end
-        end while next_batch
+          break unless next_batch
+        end
         nil
       end
 
@@ -71,18 +73,22 @@ module Ashikawa
       #   cursor = Ashikawa::Core::Cursor.new(database, raw_cursor)
       #   cursor.delete
       def delete
-        @database.send_request("cursor/#{@id}", :delete => {})
+        @database.send_request("cursor/#{@id}", delete: {})
       end
 
       private
 
-      # Parse a raw document and return a Document or Edge for it
+      # Parse a raw document and return a Document, an Edge or a raw object
       #
       # @param [Hash] raw_document
-      # @return Document | Edge
+      # @return Document | Edge | Object
       # @api private
       def parse_raw_document(raw_document)
-        detect_document_class_for(raw_document).new(@database, raw_document)
+        if raw_document.class == Hash
+          detect_document_class_for(raw_document).new(@database, raw_document)
+        else
+          raw_document
+        end
       end
 
       # Detect if a raw document is a document or edge and return the class
@@ -91,7 +97,7 @@ module Ashikawa
       # @return class
       # @api private
       def detect_document_class_for(raw_document)
-        if raw_document.has_key?("_from") && raw_document.has_key?("_to")
+        if raw_document.key?('_from') && raw_document.key?('_to')
           Edge
         else
           Document
@@ -117,7 +123,7 @@ module Ashikawa
       # @api private
       def parse_documents_cursor(raw_cursor)
         @current = raw_cursor['result']
-        @length  = raw_cursor['count'].to_i if raw_cursor.has_key?('count')
+        @length  = raw_cursor['count'].to_i if raw_cursor.key?('count')
       end
 
       # Get a new batch from the server
@@ -126,7 +132,7 @@ module Ashikawa
       # @api private
       def next_batch
         return false unless @has_more
-        raw_cursor = @database.send_request("cursor/#{@id}", :put => {})
+        raw_cursor = @database.send_request("cursor/#{@id}", put: {})
         parse_raw_cursor(raw_cursor)
       end
     end

data/lib/ashikawa-core/database.rb

@@ -1,19 +1,20 @@
-require "ashikawa-core/exceptions/client_error/resource_not_found/collection_not_found"
-require "ashikawa-core/collection"
-require "ashikawa-core/connection"
-require "ashikawa-core/cursor"
-require "ashikawa-core/configuration"
-require "ashikawa-core/transaction"
-require "forwardable"
-require "equalizer"
+# -*- encoding : utf-8 -*-
+require 'ashikawa-core/exceptions/client_error/resource_not_found/collection_not_found'
+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
     # An ArangoDB database
     class Database
       COLLECTION_TYPES = {
-        :document => 2,
-        :edge => 3
+        document: 2,
+        edge: 3
       }
 
       extend Forwardable
@@ -25,30 +26,36 @@ module Ashikawa
       def_delegator :@connection, :host
       def_delegator :@connection, :port
       def_delegator :@connection, :scheme
-      def_delegator :@connection, :authenticate_with
 
       # Initializes the connection to the database
       #
       # @api public
       # @example Access a Database by providing the URL
       #   database = Ashikawa::Core::Database.new do |config|
-      #     config.url = "http://localhost:8529"
+      #     config.url = 'http://localhost:8529'
       #   end
-      # @example Access a Database by providing a Connection
-      #   connection = Connection.new("http://localhost:8529")
+      # @example Access a Database by providing a Connection and authentication
+      #   connection = Connection.new('http://localhost:8529')
       #   database = Ashikawa::Core::Database.new do |config|
       #     config.connection = connection
+      #     config.username = 'lebowski'
+      #     config.password = 'i<3bowling'
+      #   end
+      # @example Access a certain database from ArangoDB
+      #   database = Ashikawa::Core::Database.new do |config|
+      #     config.url = 'http://localhost:8529/_db/my_db'
+      #     config.connection = connection
       #   end
       # @example Access a Database with a logger and custom HTTP adapter
       #   database = Ashikawa::Core::Database.new do |config|
-      #     config.url = "http://localhost:8529"
+      #     config.url = 'http://localhost:8529'
       #     config.adapter = my_adapter
       #     config.logger = my_logger
       #   end
       def initialize
         configuration = Ashikawa::Core::Configuration.new
         yield(configuration)
-        @connection = configuration.connection || setup_new_connection(configuration.url, configuration.logger, configuration.adapter)
+        @connection = configuration.connection
       end
 
       # Returns a list of all non-system collections defined in the database
@@ -56,12 +63,12 @@ module Ashikawa
       # @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">]
+      #   database = Ashikawa::Core::Database.new('http://localhost:8529')
+      #   database['a']
+      #   database['b']
+      #   database.collections # => [ #<Collection name='a'>, #<Collection name="b">]
       def collections
-        all_collections_where { |collection| !collection["name"].start_with?("_") }
+        all_collections_where { |collection| !collection['name'].start_with?('_') }
       end
 
       # Returns a list of all system collections defined in the database
@@ -69,10 +76,10 @@ module Ashikawa
       # @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">]
+      #   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?("_") }
+        all_collections_where { |collection| collection['name'].start_with?('_') }
       end
 
       # Create a Collection based on name
@@ -83,10 +90,10 @@ module Ashikawa
       # @return [Collection]
       # @api public
       # @example Create a new, volatile collection
-      #   database = Ashikawa::Core::Database.new("http://localhost:8529")
-      #   database.create_collection("a", :isVolatile => true) # => #<Collection name="a">
+      #   database = Ashikawa::Core::Database.new('http://localhost:8529')
+      #   database.create_collection('a', :isVolatile => true) # => #<Collection name="a">
       def create_collection(collection_identifier, opts = {})
-        response = send_request("collection", :post => translate_params(collection_identifier, opts))
+        response = send_request('collection', post: translate_params(collection_identifier, opts))
         Ashikawa::Core::Collection.new(self, response)
       end
 
@@ -96,30 +103,30 @@ module Ashikawa
       # @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">
+      #   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>
+      #   database = Ashikawa::Core::Database.new('http://localhost:8529')
+      #   database['7254820'] # => #<Collection id=7254820>
       def collection(collection_identifier)
         begin
           response = send_request("collection/#{collection_identifier}")
         rescue CollectionNotFoundException
-          response = send_request("collection", :post => { :name => collection_identifier })
+          response = send_request('collection', post: { name: collection_identifier })
         end
 
         Ashikawa::Core::Collection.new(self, response)
       end
 
-      alias :[] :collection
+      alias_method :[], :collection
 
       # Return a Query initialized with this database
       #
       # @return [Query]
       # @api public
       # @example Send an AQL query to the database
-      #   database = Ashikawa::Core::Database.new("http://localhost:8529")
-      #   database.query.execute "FOR u IN users LIMIT 2" # => #<Cursor id=33>
+      #   database = Ashikawa::Core::Database.new('http://localhost:8529')
+      #   database.query.execute 'FOR u IN users LIMIT 2' # => #<Cursor id=33>
       def query
         Query.new(self)
       end
@@ -132,29 +139,32 @@ module Ashikawa
       # @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 = 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
+      # Authenticate with given username and password
       #
-      # @param [String] url
-      # @param [Logger] logger
-      # @param [Adapter] adapter
-      # @return [Connection]
-      # @api private
-      def setup_new_connection(url, logger, adapter)
-        raise(ArgumentError, "Please provide either an url or a connection to setup the database") if url.nil?
-        Ashikawa::Core::Connection.new(url, {
-          :logger => logger,
-          :adapter => adapter
-        })
+      # @option [String] username
+      # @option [String] password
+      # @return [self]
+      # @raise [ArgumentError] if username or password are missing
+      # @api public
+      # @deprecated Use the initialization block instead
+      # @example Authenticate with the database for all future requests
+      #   database = Ashikawa::Core::Database.new do |config|
+      #     config.url = 'http://localhost:8529'
+      #   end
+      #   database.authenticate_with(:username => 'james', :password => 'bond')
+      def authenticate_with(options = {})
+        warn 'authenticate_with is deprecated. Please use the config block instead.'
+        @connection.authenticate_with(options)
       end
 
+      private
+
       # Parse a raw collection
       #
       # @param [Array] raw_collections
@@ -173,10 +183,10 @@ module Ashikawa
       # @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]
+          type: key_options[:type].to_s,
+          offset: key_options[:offset],
+          increment: key_options[:increment],
+          allowUserKeys: key_options[:allow_user_keys]
         }
       end
 
@@ -187,10 +197,10 @@ module Ashikawa
       # @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 = { name: collection_identifier }
+        params[:isVolatile] = true if opts[:is_volatile]
+        params[:type] = COLLECTION_TYPES[opts[:content_type]] if opts.key?(:content_type)
+        params[:keyOptions] = translate_key_options(opts[:key_options]) if opts.key?(:key_options)
         params
       end
 
@@ -202,7 +212,7 @@ module Ashikawa
       # @return [Array<Collection>]
       # @api private
       def all_collections_where(&block)
-        raw_collections = send_request("collection")["collections"]
+        raw_collections = send_request('collection')['collections']
         raw_collections.keep_if(&block)
         parse_raw_collections(raw_collections)
       end