cloak\result\collection\CoverageResultCollection

Complexity

Total Complexity

15

Size/Duplication

Total Lines	129
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes	4
Bugs	1	Features	0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	add()	0	4	1
A	addAll()	0	6	2
A	merge()	0	7	2
A	exclude()	0	12	2
A	select()	0	8	1
A	selectByCoverageLessThan()	0	7	1
A	selectByCoverageGreaterEqual()	0	7	1
A	sortByCodeCoverage()	0	9	1
A	compareCoverage()	0	11	3

<?php

/**
 * This file is part of cloak.
 *
 * (c) Noritaka Horio <holy.shared.design@gmail.com>
 *
 * This source file is subject to the MIT license that is bundled
 * with this source code in the file LICENSE.
 */

namespace cloak\result\collection;

use cloak\value\Coverage;
use cloak\collection\PairStackable;
use cloak\result\Specification;
use cloak\result\CoverageResultNodeCollection;
use cloak\result\CoverageResultNode;
use cloak\result\specification\Critical;
use cloak\result\specification\Satisfactory;
use PhpCollection\Map;


/**
 * Class CoverageResultCollection
 * @package cloak\result\collection
 */
class CoverageResultCollection implements CoverageResultNodeCollection
{

    use PairStackable;


    /**
     * @param \cloak\result\CoverageResultNode[] $results
     */
    public function __construct(array $results = [])
    {
        $this->collection = new Map($results);
    }

    /**
     * @param \cloak\result\CoverageResultNode $result
     */
    public function add(CoverageResultNode $result)
    {
        $this->collection->set($result->getName(), $result);
    }

    /**
     * @param CoverageResultNode[] $results
     */
    public function addAll(array $results)
    {
        foreach ($results as $result) {
            $this->add($result);
        }
    }

    /**
     * @param CoverageResultNodeCollection $results
     * @return CoverageResultCollection|void
     */
    public function merge(CoverageResultNodeCollection $results)
    {
        foreach ($results as $result) {
            $this->add($result);
        }
        return $this;
    }

    /**
     * @param CoverageResultNodeCollection $excludeResults
     * @return CoverageResultCollection
     */
    public function exclude(CoverageResultNodeCollection $excludeResults)
    {
        $results = clone $this->collection;

        foreach ($excludeResults as $excludeResult) {
            $key = $excludeResult->getName();
            $results->remove($key);
        }
        $results = $this->createArray($results);

        return new self($results);
    }

    /**
     * @param Specification $specification
     * @return CoverageResultCollection
     */
    public function select(Specification $specification)
    {
        $arguments = [$specification, 'match'];
        $results = $this->collection->filter($arguments);
        $results = $this->createArray($results);

        return new self($results);
    }

    /**
     * @param Coverage $coverage
     * @return CoverageResultCollection
     */
    public function selectByCoverageLessThan(Coverage $coverage)
    {
        $specification = Critical::createFromCoverage($coverage);
        $result = $this->select($specification)->sortByCodeCoverage();

        return $result;
    }

    /**
     * @param Coverage $coverage
     * @return CoverageResultCollection
     */
    public function selectByCoverageGreaterEqual(Coverage $coverage)
    {
        $specification = Satisfactory::createFromCoverage($coverage);
        $result = $this->select($specification)->sortByCodeCoverage();

        return $result;
    }

    /**
     * @return CoverageResultCollection
     */
    private function sortByCodeCoverage()
    {
        $results = clone $this->collection;
        $results = $this->createArray($results);

        uasort($results, [$this, 'compareCoverage']);

        return new self($results);
    }

    /**
     * @param CoverageResultNode $resultA
     * @param CoverageResultNode $resultB
     * @return int
     */
    private function compareCoverage(CoverageResultNode $resultA, CoverageResultNode $resultB)
    {
        $coverageA = $resultA->getCodeCoverage();
        $coverageB = $resultB->getCodeCoverage();

        if ($coverageA === $coverageB) {
            return 0;
        }

        return ($coverageA < $coverageB) ? -1 : 1;
    }

}