Ktomk\Pipelines\File\Pipeline\StepCaches

Complexity

Total Complexity

17

Size/Duplication

Total Lines	130
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	0	Features	0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	getNames()	0	3	1
A	getIterator()	0	3	1
A	getFile()	0	3	1
A	__construct()	0	8	1
A	getDefinitions()	0	7	2
A	parseCaches()	0	18	5
A	getCacheDefinitionByName()	0	7	3
A	verifyCache()	0	9	3

<?php

/* this file is part of pipelines */

namespace Ktomk\Pipelines\File\Pipeline;

use Ktomk\Pipelines\File\Definitions\Caches;
use Ktomk\Pipelines\File\Dom\FileNode;
use Ktomk\Pipelines\File\File;
use Ktomk\Pipelines\File\ParseException;

/**
 * Class StepCaches
 *
 * Caches entry in a step
 *
 * @package Ktomk\Pipelines\File\File
 */
class StepCaches implements FileNode, \IteratorAggregate
{
    /**
     * @var Step
     */
    private $step;

    /**
     * @var array
     * @psalm-var array<string, int>
     */
    private $caches;

    /**
     * StepCaches constructor.
     *
     * @param Step $step
     * @param null|array|mixed $caches
     *
     * @return void
     */
    public function __construct(Step $step, $caches)
    {
        $this->step = $step;

        // quick validation: script
        $parsed = $this->parseCaches($caches);

        $this->caches = array_flip($parsed);
    }

    /**
     * get step caches (as defined)
     *
     * @return array cache map
     */
    public function getDefinitions()
    {
        if (null === $file = $this->getFile()) {
            return array();
        }

        return $file->getDefinitions()->getCaches()->getByNames($this->getNames());
    }

    /**
     * Get all cache names of step
     *
     * @return array|string[]
     */
    public function getNames()
    {
        return array_keys($this->caches);
    }

    /**
     * @return null|File
     */
    public function getFile()
    {
        return $this->step->getFile();
    }

    /**
     * @return \ArrayIterator|string[]
     */
    public function getIterator()
    {
        return new \ArrayIterator($this->getDefinitions());
    }

    /**
     * parse caches
     *
     * @param null|array|mixed $caches
     *
     * @return string[]
     */
    private function parseCaches($caches)
    {
        if (!is_array($caches)) {
            throw new ParseException("'caches' requires a list of caches");
        }

        $reservoir = array();
        foreach ($caches as $cache) {
            if (!is_string($cache)) {
                throw new ParseException("'caches' cache name string expected");
            }

            '' === ($cache = trim($cache)) || $reservoir[] = $cache;

            $this->verifyCache($cache);
        }

        return $reservoir;
    }

    /**
     * @param $cache
     *
     * @throws ParseException
     *
     * @return void
     */
    private function verifyCache($cache)
    {
        if ('' === $cache) {
            throw new ParseException("'caches' cache name must not be empty");
        }

        if (null === $this->getCacheDefinitionByName($cache)) {
            throw new ParseException(
                sprintf("cache '%s' must reference a custom or default cache definition", $cache)
            );
        }
    }

    /**
     * @param string $name
     *
     * @return null|string|true
     */
    private function getCacheDefinitionByName($name)
    {
        $file = $this->step->getFile();

        $definitions = $file ? $file->getDefinitions()->getCaches() : $file;

$file is of type Ktomk\Pipelines\File\File, thus it always evaluated to true.

        return $definitions ? $definitions->getByName($name) : null;

$definitions is of type Ktomk\Pipelines\File\Definitions\Caches, thus it always evaluated to true.

    }
}