Ktomk\Pipelines\Utility\FileShower

Complexity

Total Complexity

59

Size/Duplication

Total Lines	380
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	4
Bugs	1	Features	0

17 Methods

Rating	Name	Duplication	Size	Complexity
A	showImages()	0	14	3
A	__construct()	0	4	1
A	showPipelineIds()	0	9	2
B	showPipelines()	0	26	7
A	showFile()	0	22	5
A	showServices()	0	33	5
A	getShowPipeline()	0	14	3
A	getImagesAndNames()	0	17	4
A	textTableGetRow()	0	11	3
A	getAllStepsWithServices()	0	12	3
A	info()	0	3	1
A	textTable()	0	7	2
A	getAllSteps()	0	10	3
A	tableStepsServices()	0	22	5
A	tableFileStepsServices()	0	9	4
A	textTableGetSizes()	0	14	4
A	tableFileSteps()	0	20	4

<?php

/* this file is part of pipelines */

namespace Ktomk\Pipelines\Utility;

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

/**
 * Class FileShower
 *
 * Shows information about a file
 *
 * @package Ktomk\Pipelines\Utility
 */
class FileShower
{
    /**
     * @var callable
     */
    private $output;

    /**
     * @var File
     */
    private $file;

    /**
     * FileInfo constructor.
     *
     * @param callable $output
     * @param File $file
     */
    public function __construct($output, File $file)
    {
        $this->output = $output;
        $this->file = $file;
    }

    /**
     * @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($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();

        $errors = 0;
        $table = array(array('PIPELINE ID', 'STEP', 'IMAGE', 'NAME'));
        foreach ($pipelines->getPipelineIds() as $id) {
            list($pipeline, $message) = $this->getShowPipeline($pipelines, $id);
            if ($message) {
                $table[] = array($id, 'ERROR', $message, '');
                $errors++;

                continue;
            }

            $steps = (null === $pipeline) ? array() : $pipeline->getSteps();
            list($table, $errors) = $this->tableFileSteps($steps, $id, $table, $errors);
        }

        $this->textTable($table);

        return $errors ? 1 : 0;
    }

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

        $errors = 0;
        $table = array(array('PIPELINE ID', 'IMAGES', 'STEPS'));
        foreach ($pipelines->getPipelineIds() as $id) {
            list($pipeline, $message) = $this->getShowPipeline($pipelines, $id);
            if ($message) {
                $table[] = array($id, 'ERROR', $message);
                $errors++;

                continue;
            }

            $steps = (null === $pipeline) ? null : $pipeline->getSteps();
            list($images, $names) = $this->getImagesAndNames($steps);

            $images = $images ? implode(', ', $images) : '';
            $steps = sprintf('%d%s', count($steps), $names ? ' ("' . implode('"; "', $names) . '")' : '');
            $table[] = array($id, $images, $steps);
        }

        $this->textTable($table);

        return $errors ? 1 : 0;
    }

    public function showServices()
    {
        $file = $this->file;
        $pipelines = $file->getPipelines();

        $errors = 0;
        $table = array(array('PIPELINE ID', 'STEP', 'SERVICE', 'IMAGE'));

        try {
            $serviceDefinitions = $file->getDefinitions()->getServices();
        } catch (ParseException $e) {
            $table[] = array('', '', 'ERROR', $e->getParseMessage());
            $this->textTable($table);

            return 1;
        }

        foreach ($pipelines->getPipelineIds() as $id) {
            list($pipeline, $message) = $this->getShowPipeline($pipelines, $id);
            if ($message) {
                $table[] = array($id, '', 'ERROR', $message);
                $errors++;

                continue;
            }

            list($table, $errors) =
                $this->tableStepsServices($pipeline->getSteps(), $serviceDefinitions, $id, $table, $errors);
        }

        $this->textTable($table);

        return $errors ? 1 : 0;
    }

    /**
     * @param Step[]|Steps $steps
     * @param string $id
     * @param array $table
     * @param int $errors
     *
     * @return array
     */
    private function tableFileSteps($steps, $id, array $table, $errors)
    {
        foreach ($steps as $index => $step) {
            /** @var Step $step */
            $name = $step->getName();
            null !== $name && $name = sprintf('"%s"', $name);
            null === $name && $name = 'no-name';

            $table[] = array($id, $index + 1, $step->getImage(), $name);
            list($table, $errors) = $this->tableFileStepsServices(
                $step->getServices()->getServiceNames(),
                $step,
                $id,
                $index + 1,
                $table,
                $errors
            );
        }

        return array($table, $errors);
    }

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

        return array($table, $errors);
    }

    private function tableStepsServices(Steps $steps, $serviceDefinitions, $id, array $table, $errors)
    {
        foreach ($steps as $step) {
            /** @var Step $step */
            $serviceNames = $step->getServices()->getServiceNames();
            if (!$serviceNames) {

The expression $serviceNames of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using empty($expr) instead to make it clear that you intend to check for an array without elements.

                continue;
            }

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

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

        return array($table, $errors);
    }

    /**
     * @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 Pipelines $pipelines
     * @param string $id
     *
     * @return array
     */
    private function getShowPipeline(Pipelines $pipelines, $id)
    {
        $pipeline = null;

The assignment to $pipeline is dead and can be removed.

        $message = null;

        try {
            $pipeline = $pipelines->getById($id);
        } catch (ParseException $exception) {
            $message = $exception->getParseMessage();
        } catch (InvalidArgumentException $exception) {
            $message = $exception->getMessage();
        }

        return array($pipeline, $message);
    }

    /**
     * @param array $table
     *
     * @return void
     */
    private function textTable(array $table)
    {
        $sizes = $this->textTableGetSizes($table);

        foreach ($table as $row) {
            $line = $this->textTableGetRow($row, $sizes);
            $this->info($line);
        }
    }

    /**
     * @param string $message
     *
     * @return void
     */
    private function info($message)
    {
        call_user_func($this->output, $message);
    }

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

        foreach (Steps::fullIter($steps) as $step) {
            $image = $step->getImage()->getName();
            if (File::DEFAULT_IMAGE !== $image) {
                $images[] = $image;
            }
            $name = $step->getName();
            (null !== $name) && $names[] = $name;
        }

        $images = array_unique($images);

        return array($images, $names);
    }

    /**
     * get max sizes for each column in array table
     *
     * @param array $table
     *
     * @return array|int[] sizes
     */
    private function textTableGetSizes(array $table)
    {
        $sizes = array();
        foreach ($table[0] as $index => $cell) {
            $sizes[$index] = 0;
        }

        foreach ($table as $row) {
            foreach ($row as $index => $column) {
                $sizes[$index] = max($sizes[$index], strlen($column));
            }
        }

        return $sizes;
    }

    /**
     * @param array|string[] $row
     * @param array|int[] $sizes
     *
     * @return string
     */
    private function textTableGetRow(array $row, array $sizes)
    {
        $line = '';
        foreach ($row as $index => $column) {
            $len = strlen($column);
            $index && $line .= '    ';
            $line .= $column;
            $line .= str_repeat(' ', $sizes[$index] - $len);
        }

        return $line;
    }
}