KGzocha\Searcher\Chain\ChainSearch

Complexity

Total Complexity

11

Size/Duplication

Total Lines	97
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

100%

Importance

Changes	6
Bugs	0	Features	2

4 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
B	search()	0	24	4
A	validateCells()	0	19	4
A	addResult()	0	11	2

<?php

namespace KGzocha\Searcher\Chain;

use KGzocha\Searcher\Criteria\Collection\CriteriaCollectionInterface;
use KGzocha\Searcher\Result\ResultCollection;
use KGzocha\Searcher\SearcherInterface;

/**
 * This class represents whole chain of searchers, but it behaves like regular searcher.
 * It will perform all (not skipped) sub-searches, transform theirs results into CriteriaCollection
 * and pass those criteria to next sub-search.
 * At the end it will return collection of all the results from all the steps.
 *
 * @author Krzysztof Gzocha <krzysztof@propertyfinder.ae>
 */
class ChainSearch implements SearcherInterface
{
    const MINIMUM_CELLS = 2;

    /**
     * @var CellInterface[]
     */
    private $cells;

    /**
     * @param CellInterface[] $cells
     */
    public function __construct(array $cells)
    {
        $this->validateCells($cells);
        $this->cells = $cells;
    }

    /**
     * Will perform multiple sub-searches.
     * Results from first search will be transformed and passed as CriteriaCollection
     * to another sub-search.
     * Whole process will return collection of results from each sub-search.
     *
     * @param CriteriaCollectionInterface $criteriaCollection
     *
     * @return ResultCollection
     */
    public function search(
        CriteriaCollectionInterface $criteriaCollection
    ) {
        $previousCriteria = $criteriaCollection;
        $previousResults = null;
        $result = new ResultCollection();

        foreach ($this->cells as $cell) {
            if ($cell->getTransformer()->skip($previousResults)) {
                continue;
            }

            $previousResults = $cell->getSearcher()->search($previousCriteria);
            if ($cell->hasTransformer()) {
                $previousCriteria = $cell
                    ->getTransformer()
                    ->transform($previousResults, $previousCriteria);
            }

            $this->addResult($result, $cell, $previousResults);
        }

        return $result;
    }

    /**
     * @param CellInterface[] $cells
     *
     * @throws \InvalidArgumentException
     */
    private function validateCells(array $cells)
    {
        if (self::MINIMUM_CELLS > count($cells)) {
            throw new \InvalidArgumentException(
                'At least two searchers are required to create a chain'
            );
        }

        foreach ($cells as $cell) {
            if ($cell instanceof CellInterface) {
                continue;
            }

            throw new \InvalidArgumentException(sprintf(
                'All cells passed to %s should be object and must implement CellInterface',
                get_class($this)
            ));
        }
    }

    /**
     * @param ResultCollection $result
     * @param CellInterface    $cell
     * @param mixed            $previousResults
     *
     * @return ResultCollection
     */
    private function addResult(
        ResultCollection $result,
        CellInterface $cell,
        $previousResults
    ) {
        if ($cell->getName()) {

The expression $cell->getName() of type null|string is loosely compared to true; this is ambiguous if the string can be empty. You might want to explicitly use !== null instead.

            return $result->addNamedItem($cell->getName(), $previousResults);
        }

        return $result->addItem($previousResults);
    }
}