Ktomk\Pipelines\Utility\Show\FileShower

Complexity

Total Complexity

45

Size/Duplication

Total Lines	307
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	0	Features	0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	stepName()	0	5	2
A	tableFileStepsCaches()	0	10	3
A	tableFileSteps()	0	16	3
A	showImages()	0	14	3
A	getAllSteps()	0	10	3
A	tableFileStepsServices()	0	8	3
A	showPipelineIds()	0	9	2
A	showPipelines()	0	20	5
A	getImagesNamesAndAnnotations()	0	18	3
A	tableStepsServices()	0	15	5
A	showFile()	0	12	3
A	getAllStepsWithServices()	0	12	3
A	annotate()	0	9	2
A	stepAnnotation()	0	7	2
A	showServices()	0	16	3

<?php

/* this file is part of pipelines */

namespace Ktomk\Pipelines\Utility\Show;

use InvalidArgumentException;
use Ktomk\Pipelines\File\Definitions\Service;
use Ktomk\Pipelines\File\Definitions\Services;
use Ktomk\Pipelines\File\File;
use Ktomk\Pipelines\File\ParseException;
use Ktomk\Pipelines\File\Pipeline\Step;
use Ktomk\Pipelines\File\Pipeline\Steps;

/**
 * Class FileShower
 *
 * Shows information about a file
 *
 * @package Ktomk\Pipelines\Utility
 */
class FileShower extends FileShowerAbstract
{
    const NO_NAME = 'no-name';
    const CHAR_MANUAL = 'M';

    /**
     * @throws InvalidArgumentException
     *
     * @return int
     */
    public function showImages()
    {
        $images = array();

        foreach ($this->getAllStepsWithServices($this->file) as $step) {
            $image = $step->getImage();
            $images[(string)$image] = $image;
        }

        foreach ($images as $image) {
            $this->info((string)$image);
        }

        return 0;
    }

    /**
     * @return int
     */
    public function showPipelineIds()
    {
        $pipelines = $this->file->getPipelines();

        foreach ($pipelines->getPipelineIds() as $id) {
            $this->info($id);
        }

        return 0;
    }

    /**
     * shows pipeline and steps
     *
     * @return int 0 if there were no errors, 1 if there were errors
     */
    public function showFile()
    {
        $pipelines = $this->file->getPipelines();

        $table = new FileTable(array('PIPELINE ID', 'STEP', 'IMAGE', 'NAME'));

        foreach ($this->tablePipelineIdsPipelines($pipelines, $table) as $id => $pipeline) {
            $steps = (null === $pipeline) ? array() : $pipeline->getSteps();
            $this->tableFileSteps($steps, $id, $table);
        }

        return $this->outputTableAndReturn($table);
    }

    /**
     * shows summary of the file, first pipelines then pipeline services
     *
     * @return int 0 if there were no errors, 1 if there were errors
     */
    public function showPipelines()
    {
        $pipelines = $this->file->getPipelines();

        $table = new FileTable(array('PIPELINE ID', 'IMAGES', 'STEPS'));

        foreach ($this->tablePipelineIdsPipelines($pipelines, $table) as $id => $pipeline) {
            $steps = (null === $pipeline) ? null : $pipeline->getSteps();
            list($images, $names, $annotations) = $this->getImagesNamesAndAnnotations($steps);

            $images = $images ? implode(', ', $images) : '';
            $steps = sprintf(
                '%d%s',
                count($steps),

It seems like $steps can also be of type null; however, parameter $value of count() does only seem to accept Countable|array, maybe add an additional type check?

                $names ? ' (' . implode('; ', $this->annotate($names, ' *', $annotations)) . ')' : ''
            );
            $table->addRow(array($id, $images, $steps));
        }

        return $this->outputTableAndReturn($table);
    }

    /**
     * @return int
     */
    public function showServices()
    {
        $file = $this->file;

        $table = new FileTable(array('PIPELINE ID', 'STEP', 'SERVICE', 'IMAGE'));

        try {
            $serviceDefinitions = $file->getDefinitions()->getServices();
            foreach ($this->tablePipelineIdsPipelines($file->getPipelines(), $table) as $id => $pipeline) {
                $this->tableStepsServices($pipeline->getSteps(), $serviceDefinitions, $id, $table);
            }
        } catch (ParseException $e) {
            $table->addErrorRow(array('', '', 'ERROR', $e->getParseMessage()));
        }

        return $this->outputTableAndReturn($table);
    }

    /**
     * @param array<string> $names
     * @param string $annotator
     * @param array<string> $annotations
     *
     * @return array|string[]
     */
    private function annotate(array $names, $annotator, array $annotations)
    {
        return array_map(function ($name, $annotations) use ($annotator) {
            if ($annotations) {
                $name .= $annotator . implode('', $annotations);
            }

            return $name;
        }, $names, $annotations);
    }

    /**
     * @param Step[]|Steps $steps
     * @param string $id
     * @param FileTable $table
     *
     * @return void
     */
    private function tableFileSteps($steps, $id, FileTable $table)
    {
        foreach ($steps::fullIter($steps) as $index => $step) {
            $stepNumber = (int)$index + 1;
            $name = $step->getName();
            $name = null === $name ? self::NO_NAME : sprintf('"%s"', $name);

            $stepNumberAnnotated = $this->annotate(
                array((string)$stepNumber),
                ' *',
                array($this->stepAnnotation($step))
            );

            $table->addRow(array($id, $stepNumberAnnotated[0], $step->getImage(), $name));
            $this->tableFileStepsCaches($step, $id, $stepNumber, $table);
            $this->tableFileStepsServices($step, $id, $stepNumber, $table);
        }
    }

    /**
     * @param Step $step
     * @param string $id
     * @param int $stepNumber 1 based
     * @param FileTable $table
     *
     * @return void
     */
    private function tableFileStepsCaches(Step $step, $id, $stepNumber, FileTable $table)
    {
        $caches = $step->getCaches();
        $cacheDefinitions = $step->getFile()->getDefinitions()->getCaches();

        foreach ($caches->getNames() as $cacheName) {
            $cacheLabel = 'cache: ' . $cacheName;
            $definition = $cacheDefinitions->getByName($cacheName);
            $cacheDescription = true === $definition ? '*internal*' : $definition;
            $table->addRow(array($id, $stepNumber, $cacheLabel, $cacheDescription));
        }
    }

    /**
     * @param Step $step
     * @param string $id
     * @param int $stepNumber 1 based
     * @param FileTable $table
     *
     * @return void
     */
    private function tableFileStepsServices(Step $step, $id, $stepNumber, FileTable $table)
    {
        foreach ($step->getServices()->getServiceNames() as $serviceName) {
            /** @var Service $service */
            $service = $step->getFile()->getDefinitions()->getServices()->getByName($serviceName);
            $table->addFlaggedRow(
                $service,
                array($id, $stepNumber, $service ? $service->getImage() : 'ERROR', 'service:' . $serviceName)
            );
        }
    }

    /**
     * @param Steps $steps
     * @param Services $serviceDefinitions
     * @param string $id
     * @param FileTable $table
     *
     * @return void
     */
    private function tableStepsServices(Steps $steps, Services $serviceDefinitions, $id, FileTable $table)
    {
        foreach ($steps as $step) {
            $serviceNames = $step->getServices()->getServiceNames();
            if (empty($serviceNames)) {
                continue;
            }

            $stepNo = $step->getIndex() + 1;

            foreach ($serviceNames as $name) {
                if ($service = $serviceDefinitions->getByName($name)) {
                    $table->addRow(array($id, $stepNo, $name, $service->getImage()));
                } else {
                    $table->addErrorRow(array($id, $stepNo, 'ERROR', sprintf('Undefined service: "%s"', $name)));
                }
            }
        }
    }

    /**
     * @param File $file
     *
     * @return Step[]
     */
    private function getAllSteps(File $file)
    {
        $return = array();
        foreach ($file->getPipelines()->getPipelines() as $id => $pipeline) {
            foreach (Steps::fullIter($pipeline->getSteps()) as $index => $step) {
                $return["${id}:/step/${index}"] = $step;
            }
        }

        return $return;
    }

    /**
     * step iterator w/services
     *
     * @param File $file
     *
     * @return Service[]|Step[]
     */
    private function getAllStepsWithServices(File $file)
    {
        $return = array();

        foreach ($this->getAllSteps($file) as $key => $step) {
            $return[$key] = $step;
            foreach ($step->getServices()->getDefinitions() as $name => $service) {
                $return["${key}/service/${name}"] = $service;
            }
        }

        return $return;
    }

    /**
     * @param Steps $steps
     *
     * @return array
     */
    private function getImagesNamesAndAnnotations(Steps $steps = null)
    {
        $images = array();
        $names = array();
        $annotations = array();

        foreach (Steps::fullIter($steps) as $step) {
            $image = $step->getImage()->getName();
            if (File::DEFAULT_IMAGE !== $image) {
                $images[] = $image;
            }
            $names[] = $this->stepName($step);
            $annotations[] = $this->stepAnnotation($step);
        }

        $images = array_unique($images);

        return array($images, $names, $annotations);
    }

    /**
     * @param Step $step
     *
     * @return string
     */
    private function stepName(Step $step)
    {
        $name = $step->getName();

        return null === $name ? self::NO_NAME : sprintf('"%s"', $name);
    }

    /**
     * @param Step $step
     *
     * @return array
     */
    private function stepAnnotation(Step $step)
    {
        $annotations = array();

        $step->isManual() && $annotations[] = self::CHAR_MANUAL;

        return $annotations;
    }
}