Mattbit\Flat\Collection

Complexity

Total Complexity

15

Size/Duplication

Total Lines	159
Duplicated Lines	17.61 %

Coupling/Cohesion

Components	2
Dependencies	5

Test Coverage

Coverage

68.89%

Importance

Changes	2
Bugs	0	Features	0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	1
A	drop()	0	4	1
A	truncate()	0	4	1
A	insert()	0	4	1
A	update()	14	14	3
A	remove()	14	14	3
A	find()	0	4	1
A	count()	0	8	2
A	onMatch()	0	9	1
A	newMatcher()	0	4	1

<?php

namespace Mattbit\Flat;

use Mattbit\Flat\Query\Parser;
use Mattbit\Flat\Query\Matcher;
use Mattbit\Flat\Storage\DocumentStore;
use Mattbit\Flat\Model\DocumentInterface;
use Mattbit\Flat\Query\Expression\ExpressionInterface;

class Collection
{
    /**
     * @var string
     */
    protected $name;

    /**
     * @var DocumentStore
     */
    protected $store;

    /**
     * @var Database
     */
    protected $database;

    /**
     * @var Parser
     */
    protected $parser;

    /**
     * Construct a new collection.
     *
     * @param Database      $database
     * @param DocumentStore $store
     * @param string        $name
     */
    public function __construct(Database $database, DocumentStore $store, $name)
    {
        $this->name = $name;
        $this->store = $store;
        $this->database = $database;
        $this->parser = $database->getParser();
    }

    /**
     * Drop the collection.
     *
     * @return bool
     */
    public function drop()
    {
        return $this->database->dropCollection($this->name);
    }

    /**
     * Remove all the documents from the collection.
     *
     * @return bool
     */
    public function truncate()
    {
        $this->store->truncate();
    }

    /**
     * Insert a new document.
     *
     * @param DocumentInterface $document
     *
     * @return bool
     */
    public function insert(DocumentInterface $document)
    {
        return $this->store->insert($document);
    }

    /**
     * Update existing documents.
     *
     * @param array        $criteria
     * @param DocumentInterface $updated
     * @param bool         $multiple
     *
     * @return int The count of the documents updated.
     */
    public function update($criteria, DocumentInterface $updated, $multiple = false)

This method seems to be duplicated in your project.

    {
        $limit = $multiple ? 1 : null;
        $documents = $this->onMatch($criteria, $limit);

        $count = 0;
        foreach ($documents as $document) {
            $updated->setId($document->getId());
            $this->store->update($updated);
            $count++;
        }

        return $count;
    }

    /**
     * Remove documents from the collection.
     *
     * @param mixed $criteria
     * @param bool  $multiple
     *
     * @return int The count of the document deleted.
     */
    public function remove($criteria, $multiple = false)

This method seems to be duplicated in your project.

    {
        $limit = $multiple ? 1 : null;

        $documents = $this->onMatch($criteria, $limit);

        $count = 0;
        foreach ($documents as $document) {
            $this->store->remove($document->get('_id'));
            $count++;
        }

        return $count;
    }

    /**
     * Find documents in the collection.
     *
     * @param array $criteria
     *
     * @return array The array of results.
     */
    public function find($criteria = [])
    {
        return $this->onMatch($criteria);
    }

    /**
     * Count documents in the collection.
     *
     * @param array $criteria
     * 
     * @return int The number of documents.
     */
    public function count($criteria = [])
    {
        if (empty($criteria)) {
            return $this->store->count();
        }

        return count($this->onMatch($criteria));
    }

    protected function onMatch($criteria, $limit = null)
    {
        $expression = $this->parser->parse($criteria);
        $matcher = $this->newMatcher($expression);

        $documents = $this->store->scan([$matcher, 'match'], $limit);

        return $documents;
    }

    protected function newMatcher(ExpressionInterface $expression)
    {
        return new Matcher($expression);
    }
}