ashikawa-core 0.9.0 → 0.10.0

data/lib/ashikawa-core/connection.rb

@@ -4,8 +4,8 @@ require 'faraday'
 require 'null_logger'
 require 'uri'
 require 'equalizer'
-require 'ashikawa-core/request_preprocessor'
-require 'ashikawa-core/response_preprocessor'
+require 'faraday_middleware'
+require 'ashikawa-core/error_response'
 
 module Ashikawa
   module Core
@@ -45,20 +45,34 @@ module Ashikawa
       #   connection.port # => 8529
       def_delegator :@connection, :port
 
+      # The Faraday connection object
+      #
+      # @return [Faraday]
+      # @api public
+      # @example Set additional response middleware
+      #   connection = Connection.new('http://localhost:8529')
+      #   connection.connection.response :caching
+      attr_reader :connection
+
       # Initialize a Connection with a given API String
       #
       # @param [String] api_string scheme, hostname and port as a String
-      # @option opts [Object] adapter The Faraday adapter you want to use. Defaults to Default Adapter
-      # @option opts [Object] logger The logger you want to use. Defaults to Null Logger.
+      # @option options [Object] adapter The Faraday adapter you want to use. Defaults to Default Adapter
+      # @option options [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')
-      def initialize(api_string, opts = {})
-        logger  = opts[:logger]  || NullLogger.instance
-        adapter = opts[:adapter] || Faraday.default_adapter
+      def initialize(api_string, options = {})
+        logger  = options.fetch(:logger) { NullLogger.instance }
+        adapter = options.fetch(:adapter) { Faraday.default_adapter }
+
         @connection = Faraday.new("#{api_string}/_api") do |connection|
-          connection.request  :ashikawa_request,  logger
-          connection.response :ashikawa_response, logger
+          connection.request :json
+
+          connection.response :logger, logger
+          connection.response :error_response
+          connection.response :json
+
           connection.adapter(*adapter)
         end
       end
@@ -78,6 +92,8 @@ module Ashikawa
         method = http_verb(params)
         result = @connection.public_send(method, path, params[method])
         result.body
+      rescue Faraday::Error::ParsingError
+        raise Ashikawa::Core::JsonError
       end
 
       # Checks if authentication for this Connection is active or not
@@ -95,18 +111,11 @@ module Ashikawa
 
       # Authenticate with given username and password
       #
-      # @option [String] username
-      # @option [String] password
-      # @return [self]
-      # @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.authenticate_with(:username => 'james', :password => 'bond')
-      def authenticate_with(options = {})
-        raise ArgumentError, 'missing username or password' unless options.key? :username and options.key? :password
-        @authentication = @connection.basic_auth(options[:username], options[:password])
-        self
+      # @param [String] username
+      # @param [String] password
+      # @api private
+      def authenticate_with(username, password)
+        @authentication = @connection.basic_auth(username, password)
       end
 
       private

data/lib/ashikawa-core/cursor.rb

@@ -57,12 +57,11 @@ module Ashikawa
       def each
         return to_enum(__callee__) unless block_given?
 
-        loop do
+        begin
           @current.each do |raw_document|
             yield parse_raw_document(raw_document)
           end
-          break unless next_batch
-        end
+        end while next_batch
         nil
       end
 

data/lib/ashikawa-core/database.rb

@@ -53,7 +53,7 @@ module Ashikawa
       #     config.logger = my_logger
       #   end
       def initialize
-        configuration = Ashikawa::Core::Configuration.new
+        configuration = Configuration.new
         yield(configuration)
         @connection = configuration.connection
       end
@@ -85,16 +85,16 @@ module Ashikawa
       # Create a Collection based on name
       #
       # @param [String] collection_identifier The desired name of the collection
-      # @option opts [Boolean] :is_volatile Should the collection be volatile? Default is false
-      # @option opts [Boolean] :content_type What kind of content should the collection have? Default is :document
+      # @option options [Boolean] :is_volatile Should the collection be volatile? Default is false
+      # @option options [Boolean] :content_type What kind of content should the collection have? Default is :document
       # @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">
-      def create_collection(collection_identifier, opts = {})
-        response = send_request('collection', post: translate_params(collection_identifier, opts))
-        Ashikawa::Core::Collection.new(self, response)
+      def create_collection(collection_identifier, options = {})
+        response = send_request('collection', post: translate_params(collection_identifier, options))
+        Collection.new(self, response)
       end
 
       # Get or create a Collection based on name or ID
@@ -109,13 +109,10 @@ module Ashikawa
       #   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 })
-        end
-
-        Ashikawa::Core::Collection.new(self, response)
+        response = send_request("collection/#{collection_identifier}")
+        Collection.new(self, response)
+      rescue CollectionNotFoundException
+        create_collection(collection_identifier)
       end
 
       alias_method :[], :collection
@@ -142,25 +139,7 @@ module Ashikawa
       #   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
-
-      # Authenticate with given username and password
-      #
-      # @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)
+        Transaction.new(self, action, collections)
       end
 
       private
@@ -171,9 +150,7 @@ module Ashikawa
       # @return [Array]
       # @api private
       def parse_raw_collections(raw_collections)
-        raw_collections.map { |collection|
-          Ashikawa::Core::Collection.new(self, collection)
-        }
+        raw_collections.map { |collection| Collection.new(self, collection) }
       end
 
       # Translate the key options into the required format

data/lib/ashikawa-core/document.rb

@@ -95,7 +95,6 @@ module Ashikawa
       #   document = Ashikawa::Core::Document.new(database, raw_document)
       #   document['name'] = 'The dude'
       def []=(attribute_name, value)
-        check_if_persisted!
         @content[attribute_name] = value
       end
 
@@ -105,8 +104,8 @@ module Ashikawa
       # @api public
       # @example Get the hash representation of a document
       #   document = Ashikawa::Core::Document.new(database, raw_document)
-      #   document.hash #=> { :name => 'Lebowski", :occupation => "Not occupied' }
-      def hash
+      #   document.to_h #=> { :name => 'Lebowski", :occupation => "Not occupied' }
+      def to_h
         @content
       end
 
@@ -145,7 +144,7 @@ module Ashikawa
         @id       = raw_document['_id'] || :not_persisted
         @key      = raw_document['_key']
         @revision = raw_document['_rev'] || :not_persisted
-        @content  = raw_document.delete_if { |key, value| key.start_with?('_') }
+        @content  = raw_document.delete_if { |key| key.start_with?('_') }
         self
       end
 

data/lib/ashikawa-core/edge.rb

@@ -28,16 +28,16 @@ module Ashikawa
 
       # Initialize an Edge with the database and raw data
       #
-      # @param [Database] database
+      # @param [Database] _database
       # @param [Hash] raw_edge
-      # @param [Hash] additional_data
+      # @param [Hash] _additional_data
       # @api public
       # @example Create an Edge
       #   document = Ashikawa::Core::Edge.new(database, raw_edge)
-      def initialize(database, raw_edge, additional_data = {})
+      def initialize(_database, raw_edge, _additional_data = {})
         @from_id = raw_edge['_from']
         @to_id = raw_edge['_to']
-        super(database, raw_edge, additional_data)
+        super
       end
 
       protected
@@ -47,7 +47,7 @@ module Ashikawa
       # @param [Hash] opts Options for this request
       # @return [Hash] The parsed response from the server
       # @api private
-      def send_request_for_document(opts = {})
+      def send_request_for_document(opts)
         @database.send_request("edge/#{@id}", opts)
       end
     end

data/lib/ashikawa-core/error_response.rb

@@ -0,0 +1,108 @@
+# -*- encoding : utf-8 -*-
+require 'ashikawa-core/exceptions/client_error'
+require 'ashikawa-core/exceptions/client_error/resource_not_found'
+require 'ashikawa-core/exceptions/client_error/resource_not_found/index_not_found'
+require 'ashikawa-core/exceptions/client_error/resource_not_found/document_not_found'
+require 'ashikawa-core/exceptions/client_error/resource_not_found/collection_not_found'
+require 'ashikawa-core/exceptions/client_error/bad_syntax'
+require 'ashikawa-core/exceptions/client_error/authentication_failed'
+require 'ashikawa-core/exceptions/server_error'
+require 'ashikawa-core/exceptions/server_error/json_error'
+
+module Ashikawa
+  module Core
+    # A response from the server
+    class ErrorResponse < Faraday::Response::Middleware
+      # Status code for a [Bad Request](http://httpstatus.es/400)
+      BadSyntaxStatus = 400
+
+      # Status code for an [Unauthorized Request](http://httpstatus.es/401)
+      AuthenticationFailed = 401
+
+      # Status code for a [Not Found Resource](http://httpstatus.es/404)
+      ResourceNotFoundError = 404
+
+      # All other status codes for client errors
+      ClientErrorStatuses = 405...499
+
+      # All status codes for server errors
+      ServerErrorStatuses = 500...599
+
+      def on_complete(env)
+        @body = env[:body]
+        @url = env[:url]
+
+        case env[:status]
+        when BadSyntaxStatus then bad_syntax
+        when AuthenticationFailed then authentication_failed
+        when ResourceNotFoundError then resource_not_found
+        when ClientErrorStatuses then client_error
+        when ServerErrorStatuses then server_error
+        end
+      end
+
+      private
+
+      # Raise a Bad Syntax Error
+      #
+      # @raise [BadSyntax]
+      # @return nil
+      # @api private
+      def bad_syntax
+        raise BadSyntax
+      end
+
+      # Raise an Authentication Failed Error
+      #
+      # @raise [AuthenticationFailed]
+      # @return nil
+      # @api private
+      def authentication_failed
+        raise Core::AuthenticationFailed
+      end
+
+      # Raise a Client Error for a given body
+      #
+      # @raise [ClientError]
+      # @return nil
+      # @api private
+      def client_error
+        raise ClientError, error
+      end
+
+      # Raise a Server Error for a given body
+      #
+      # @raise [ServerError]
+      # @return nil
+      # @api private
+      def server_error
+        raise ServerError, error
+      end
+
+      # Raise the fitting ResourceNotFoundException
+      #
+      # @raise [DocumentNotFoundException, CollectionNotFoundException, IndexNotFoundException]
+      # @return nil
+      # @api private
+      def resource_not_found
+        raise case @url.path
+              when %r{\A(/_db/[^/]+)?/_api/document} then DocumentNotFoundException
+              when %r{\A(/_db/[^/]+)?/_api/collection} then CollectionNotFoundException
+              when %r{\A(/_db/[^/]+)?/_api/index} then IndexNotFoundException
+              else ResourceNotFound
+        end
+      end
+
+      # Read the error message for the request
+      #
+      # @param [String] The raw body of the request
+      # @return [String] The formatted error message
+      # @api private
+      def error
+        "#{@body['errorNum']}: #{@body["errorMessage"]}"
+      end
+    end
+
+    Faraday.register_middleware :response, error_response: -> { ErrorResponse }
+  end
+end

data/lib/ashikawa-core/index.rb

@@ -53,7 +53,10 @@ module Ashikawa
       #   index = Ashikawa::Core::Index.new(collection, raw_index)
       def initialize(collection, raw_index)
         @collection = collection
-        parse_raw_index(raw_index)
+        @id = raw_index['id']
+        @on = convert_to_symbols(raw_index['fields'])
+        @type = raw_index['type'].to_sym
+        @unique = raw_index['unique']
       end
 
       # Remove the index from the collection
@@ -69,19 +72,6 @@ module Ashikawa
 
       private
 
-      # Parse information returned from the server
-      #
-      # @param [Hash] raw_index
-      # @return self
-      # @api private
-      def parse_raw_index(raw_index)
-        @id = raw_index['id']
-        @on = convert_to_symbols(raw_index['fields']) if raw_index.key?('fields')
-        @type = raw_index['type'].to_sym if raw_index.key?('type')
-        @unique = raw_index['unique']
-        self
-      end
-
       # Convert all elements of an array to symbols
       #
       # @param [Array] arr

data/lib/ashikawa-core/query.rb

@@ -63,7 +63,7 @@ module Ashikawa
       # @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.by_example({ 'color' => 'red' }, { :limit => 1 }) #=> #<Cursor id=2444>
       def by_example(example = {}, options = {})
         simple_query_request('simple/by-example', { example: example }.merge(options))
       end

data/lib/ashikawa-core/transaction.rb

@@ -77,7 +77,7 @@ module Ashikawa
         @database = database
         @request_parameters = {
           action: action,
-          collections: parse_options(options),
+          collections: options,
           waitForSync: false
         }
       end
@@ -94,21 +94,6 @@ module Ashikawa
         response = @database.send_request('transaction', post: @request_parameters)
         response['result']
       end
-
-      private
-
-      # Parse the read and write collections from the options
-      #
-      # @option options [Array<String>] :write The collections you want to write to
-      # @option options [Array<String>] :read The collections you want to read from
-      # @return [Hash]
-      # @api private
-      def parse_options(options)
-        collections = {}
-        collections[:write] = options[:write] if options.key? :write
-        collections[:read] = options[:read] if options.key? :read
-        collections
-      end
     end
   end
 end

data/lib/ashikawa-core/version.rb

@@ -2,6 +2,6 @@
 module Ashikawa
   module Core
     # Current version of Ashikawa::Core
-    VERSION = '0.9.0'
+    VERSION = '0.10.0'
   end
 end

data/spec/acceptance/basic_spec.rb

@@ -146,6 +146,13 @@ describe 'Basics' do
       expect(e.to_id).to eq(b.id)
     end
 
+    it 'should be possible to get a document by either its key or its ID' do
+      collection = subject['documenttests']
+      document = collection.create_document(name: 'The Dude')
+
+      expect(collection.fetch(document.key)).to eq collection.fetch(document.id)
+    end
+
     it 'should be possible to get a single attribute by AQL query' do
       collection = subject['documenttests']
       collection.truncate!
@@ -171,15 +178,11 @@ describe 'Basics' do
 
     it 'should be possible to delete a document' do
       collection.fetch(document_key).delete
-      expect {
-        collection.fetch(document_key)
-      }.to raise_exception Ashikawa::Core::DocumentNotFoundException
+      expect { collection.fetch(document_key) }.to raise_exception Ashikawa::Core::DocumentNotFoundException
     end
 
     it "should not be possible to delete a document that doesn't exist" do
-      expect {
-        collection.fetch(123).delete
-      }.to raise_exception Ashikawa::Core::DocumentNotFoundException
+      expect { collection.fetch(123).delete }.to raise_exception Ashikawa::Core::DocumentNotFoundException
     end
 
     it 'should be possible to refresh a document' do