Respect\Structural\Driver\Mongo\Driver

Complexity

Total Complexity

18

Size/Duplication

Total Lines	149
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	2

Test Coverage

Coverage

62.5%

Importance

Changes	1
Bugs	0	Features	1

13 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	getDatabase()	0	4	1
A	getConnection()	0	4	1
A	fetch()	0	5	1
A	find()	0	4	1
A	generateQuery()	0	4	1
A	parseConditions()	0	13	2
A	getConditionArray()	0	13	3
A	prefixArrayKeys()	0	9	2
A	createMongoId()	0	7	2
A	insert()	0	4	1
A	update()	0	4	1
A	remove()	0	4	1

<?php

namespace Respect\Structural\Driver\Mongo;

use Respect\Data\CollectionIterator;
use Respect\Data\Collections\Collection;
use Respect\Structural\Driver as BaseDriver;

class Driver implements BaseDriver
{
    /**
     * @var \MongoClient
     */
    private $connection;

    /**
     * @var \MongoDB
     */
    private $database;

    /**
     * Driver constructor.
     * @param \MongoClient $connection
     * @param string $database
     */
    public function __construct(\MongoClient $connection, $database)
    {
        $this->connection = $connection;
        $this->database = $connection->{$database};
    }

    /**
     * @return \MongoDB
     */
    public function getDatabase()
    {
        return $this->database;
    }

    public function getConnection()
    {
        return $this->connection;
    }

    /**
     * @param \Iterator $cursor
     * @return array
     */
    public function fetch(\Iterator $cursor)
    {
        $cursor->next();
        return $cursor->current();
    }

    /**
     * @param array $collection
     * @param array $query
     * @return \Iterator
     */
    public function find($collection, array $query = array())
    {
        return $this->getDatabase()->{$collection}->find($query);
    }

    /**
     * @param Collection $collection
     * @return array
     */
    public function generateQuery(Collection $collection)
    {
        return $this->parseConditions($collection);
    }

    /**
     * @param Collection $collection
     * @return array
     */
    protected function parseConditions(Collection $collection)
    {
        $allCollections = CollectionIterator::recursive($collection);
        $allCollections = iterator_to_array($allCollections);
        $allCollections = array_slice($allCollections, 1);

        $condition = $this->getConditionArray($collection);

        foreach ($allCollections as $name => $coll)

It is generally a best practice to always use braces with control structures.

            $condition += $this->getConditionArray($coll, true);

        return $condition;
    }

    /**
     * @param Collection $collection
     * @param bool|false $prefix
     * @return array
     */
    protected function getConditionArray(Collection $collection, $prefix = false)
    {
        $condition = $collection->getCondition();

        if (!is_array($condition)) {
            $condition = array('_id' => $this->createMongoId($condition));
        }

        if ($prefix)

It is generally a best practice to always use braces with control structures.

            $condition = static::prefixArrayKeys($condition, $collection->getName() . ".");

        return $condition;
    }

    /**
     * @param array $array
     * @param string $prefix
     * @return array
     */
    protected static function prefixArrayKeys(array $array, $prefix)
    {
        $new = array();

        foreach ($array as $key => $value)

It is generally a best practice to always use braces with control structures.

            $new["{$prefix}{$key}"] = $value;

        return $new;
    }

    /**
     * @param int|string $id
     * @return \MongoId|\MongoInt32
     */
    protected function createMongoId($id)
    {
        if (is_int($id)) {
            return new \MongoInt32($id);
        }
        return new \MongoId($id);
    }

    /**
     * @param Collection $collection
     * @param $document
     * @return void
     */
    public function insert($collection, $document)
    {
        $this->getDatabase()->{$collection}->insert($document);
    }

    public function update($collection, $criteria, $document)
    {
        $this->getDatabase()->{$collection}->update($criteria, $document);
    }

    public function remove($collection, $criteria)
    {
        $this->getDatabase()->{$collection}->remove($criteria);
    }
}