CouchDB\Connection

Complexity

Total Complexity

23

Size/Duplication

Total Lines	236
Duplicated Lines	10.17 %

Coupling/Cohesion

Components	1
Dependencies	8

Test Coverage

Coverage

92.86%

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	2
A	getEventManager()	0	4	1
A	version()	7	7	1
A	listDatabases()	7	7	1
B	dropDatabase()	0	25	5
A	selectDatabase()	10	10	2
A	hasDatabase()	0	9	1
B	createDatabase()	0	38	6
A	__get()	0	4	1
A	__unset()	0	4	1
A	__isset()	0	4	1
A	wrapDatabase()	0	4	1

<?php

namespace CouchDB;

use CouchDB\Encoder\JSONEncoder;
use CouchDB\Events\EventArgs;
use CouchDB\Exception\Exception;
use CouchDB\Exception\InvalidDatabasenameException;
use Doctrine\Common\EventManager;
use GuzzleHttp\ClientInterface;

/**
 * @author Markus Bachmann <markus.bachmann@bachi.biz>
 */
class Connection
{
    /**
     * @var ClientInterface
     */
    private $client;

    /**
     * @var EventManager
     */
    private $eventManager;

    /**
     * @param ClientInterface $client
     * @param EventManager    $dispatcher
     */
    public function __construct(ClientInterface $client, EventManager $dispatcher = null)
    {
        $this->client = $client;
        $this->eventManager = $dispatcher ?: new EventManager();
    }

    /**
     * Return the event dispatcher.
     *
     * @return EventManager
     */
    public function getEventManager()
    {
        return $this->eventManager;
    }

    /**
     * Get the couchdb version.
     *
     * @return string
     */
    public function version()
    {
        $json = (string) $this->client->request('GET', '/')->getBody();
        $value = JSONEncoder::decode($json);

        return $value['version'];
    }

    /**
     * Show all databases.
     *
     * @return array
     */
    public function listDatabases()
    {
        $json = (string) $this->client->request('GET', '/_all_dbs')->getBody();
        $databases = JSONEncoder::decode($json);

        return $databases;
    }

    /**
     * Drop a database.
     *
     * @param string $name
     *
     * @return bool
     */
    public function dropDatabase($name)
    {
        if ($this->eventManager->hasListeners(Events::PRE_DROP_DATABASE)) {
            // @codeCoverageIgnoreStart
            $this->eventManager->dispatchEvent(Events::PRE_DROP_DATABASE, new EventArgs($this, $name));
            // @codeCoverageIgnoreEnd
        }

        $response = $this->client->request('DELETE', sprintf('/%s/', urlencode($name)));

        if (404 === $response->getStatusCode()) {
            throw new Exception(sprintf('The database "%s" does not exist', $name));
        }

        $json = (string) $response->getBody();
        $status = JSONEncoder::decode($json);

        if ($this->eventManager->hasListeners(Events::POST_DROP_DATABASE)) {
            // @codeCoverageIgnoreStart
            $this->eventManager->dispatchEvent(Events::POST_DROP_DATABASE, new EventArgs($this, $name));
            // @codeCoverageIgnoreEnd
        }

        return isset($status['ok']) && $status['ok'] === true;
    }

    /**
     * Select a database.
     *
     * @param string $name
     *
     * @throws Exception If the database doesn't exists.
     *
     * @return Database
     */
    public function selectDatabase($name)
    {
        $response = $this->client->request('GET', sprintf('/%s/', $name));

        if (404 === $response->getStatusCode()) {
            throw new Exception(sprintf('The database "%s" does not exist', $name));
        }

        return $this->wrapDatabase($name);
    }

    /**
     * Check if a database exists.
     *
     * @param string $name The database name
     *
     * @return bool
     */
    public function hasDatabase($name)
    {
        $response = $this->client->request(
            'GET',
            sprintf('/%s/', urlencode($name))
        );

        return 404 !== $response->getStatusCode();
    }

    /**
     * Creates a new database.
     *
     * @param string $name The database name
     *
     * @throws Exception If the database could not be created.
     *
     * @return Database
     */
    public function createDatabase($name)
    {
        if (preg_match('@[^a-z0-9\_\$\(\)+\-]@', $name)) {
            throw new InvalidDatabasenameException(sprintf(
                'The database name %s is invalid. The database name must match the following pattern (a-z0-9_$()+-)',
                $name
            ));
        }

        if ($this->eventManager->hasListeners(Events::PRE_CREATE_DATABASE)) {
            // @codeCoverageIgnoreStart
            $this->eventManager->dispatchEvent(Events::PRE_CREATE_DATABASE, new EventArgs($this, $name));
            // @codeCoverageIgnoreEnd
        }

        $response = $this->client->request('PUT', sprintf('/%s', $name));

        if (412 === $response->getStatusCode()) {
            throw new Exception(sprintf('The database "%s" already exist', $name));
        }

        $json = (string) $response->getBody();
        $value = JSONEncoder::decode($json);

        if (isset($value['error'])) {
            throw new Exception(sprintf('[%s] Failed to create database "%s". (%s)', $value['error'], $name, $value['reason']));
        }

        $database = $this->wrapDatabase($name);

        if ($this->eventManager->hasListeners(Events::POST_CREATE_DATABASE)) {
            // @codeCoverageIgnoreStart
            $this->eventManager->dispatchEvent(Events::POST_CREATE_DATABASE, new EventArgs($database));
            // @codeCoverageIgnoreEnd
        }

        return $database;
    }

    /**
     * Gets the database.
     *
     * @param string $name The database name
     *
     * @return Database
     *
     * @deprecated This method will be removed in version 2.     
     *
     * @codeCoverageIgnore
     */
    public function __get($name)
    {
        return $this->selectDatabase($name);
    }

    /**
     * Drop a database.
     *
     * @param string $name The databas ename
     *
     * @return bool
     *
     * @deprecated This method will be removed in version 2.
     *
     * @codeCoverageIgnore
     */
    public function __unset($name)
    {
        return $this->dropDatabase($name);
    }

    /**
     * Check if the database exist.
     *
     * @param string $name The database name
     *
     * @return bool
     *
     * @deprecated This method will be removed in version 2.
     *
     * @codeCoverageIgnore
     */
    public function __isset($name)
    {
        return $this->hasDatabase($name);
    }

    /**
     * Wraps the database to a object.
     *
     * @param string $name The database name
     *
     * @return Database
     */
    private function wrapDatabase($name)
    {
        return new Database($name, $this, $this->client);
    }
}