TreeCommand::createTreeFromTaskName() - Code Metrics - deployphp/deployer - Measure and Improve Code Quality continuously with Scrutinizer

TreeCommand::createTreeFromTaskName() C
last analyzed 2025-06-04 13:17 UTC

↳ Parent: TreeCommand

Complexity

Conditions	12
Paths	162

Size

Total Lines	51
Code Lines	29

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	29
nc	162
nop	3
dl	0
loc	51
c	0
b	0
f	0
cc	12
rs	6.45

How to fix Long Method Complexity

<?php

declare(strict_types=1);

/* (c) Anton Medvedev <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Deployer\Command;

use Deployer\Deployer;
use Deployer\Task\GroupTask;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Completion\CompletionInput;
use Symfony\Component\Console\Completion\CompletionSuggestions;
use Symfony\Component\Console\Input\InputArgument;
use Symfony\Component\Console\Input\InputInterface as Input;
use Symfony\Component\Console\Output\OutputInterface as Output;

class TreeCommand extends Command
{
    /**
     * @var Output
     */
    protected $output;
    /**
     * @var Deployer
     */
    private $deployer;
    /**
     * @var array
     */
    private $tree;
    /**
     * @var int
     */
    private $depth = 0;
    /**
     * @var array
     */
    private $openGroupDepths = [];

    public function __construct(Deployer $deployer)
    {
        parent::__construct('tree');
        $this->setDescription('Display the task-tree for a given task');
        $this->deployer = $deployer;
        $this->tree = [];
    }

    protected function configure()
    {
        $this->addArgument(
            'task',
            InputArgument::REQUIRED,
            'Task to display the tree for',
        );
    }

    protected function execute(Input $input, Output $output): int
    {
        $this->output = $output;

        $rootTaskName = $input->getArgument('task');

        $this->buildTree($rootTaskName);
        $this->outputTree($rootTaskName);
        return 0;
    }

    private function buildTree(string $taskName)
    {
        $this->createTreeFromTaskName($taskName, '', true);
    }

    private function createTreeFromTaskName(string $taskName, string $postfix = '', bool $isLast = false)
    {
        $task = $this->deployer->tasks->get($taskName);

        if (!$task->isEnabled()) {
            if (empty($postfix)) {
                $postfix = '  // disabled';
            } else {
                $postfix .= '; disabled';
            }
        }

        if ($task->getBefore()) {
            $beforePostfix = sprintf("  // before %s", $task->getName());

            foreach ($task->getBefore() as $beforeTask) {
                $this->createTreeFromTaskName($beforeTask, $beforePostfix);
            }
        }

        if ($task instanceof GroupTask) {
            $isLast = $isLast && empty($task->getAfter());

            $this->addTaskToTree($task->getName() . $postfix, $isLast);

            if (!$isLast) {
                $this->openGroupDepths[] = $this->depth;
            }

            $this->depth++;

            $taskGroup = $task->getGroup();
            foreach ($taskGroup as $subtask) {
                $isLastSubtask = $subtask === end($taskGroup);
                $this->createTreeFromTaskName($subtask, '', $isLastSubtask);
            }

            if (!$isLast) {
                array_pop($this->openGroupDepths);
            }

            $this->depth--;
        } else {
            $this->addTaskToTree($task->getName() . $postfix, $isLast);
        }

        if ($task->getAfter()) {
            $afterPostfix = sprintf("  // after %s", $task->getName());

            foreach ($task->getAfter() as $afterTask) {
                $this->createTreeFromTaskName($afterTask, $afterPostfix);
            }
        }
    }

    private function addTaskToTree(string $taskName, bool $isLast = false)
    {
        $this->tree[] = [
            'taskName' => $taskName,
            'depth' => $this->depth,
            'isLast' => $isLast,
            'openDepths' => $this->openGroupDepths,
        ];
    }

    private function outputTree(string $taskName)
    {
        $this->output->writeln("The task-tree for <info>$taskName</info>:");

        /**
         * @var int number of spaces for each depth increase
         */
        $REPEAT_COUNT = 4;

        foreach ($this->tree as $treeItem) {
            $depth = $treeItem['depth'];

            $startSymbol = $treeItem['isLast'] || $treeItem === end($this->tree) ? '└' : '├';

            $prefix = '';

            for ($i = 0; $i < $depth; $i++) {
                if (in_array($i, $treeItem['openDepths'])) {
                    $prefix .= '│' . str_repeat(' ', $REPEAT_COUNT - 1);
                } else {
                    $prefix .= str_repeat(' ', $REPEAT_COUNT);
                }
            }

            $prefix .= $startSymbol . '──';

            $this->output->writeln(sprintf('%s %s', $prefix, $treeItem['taskName']));
        }
    }

    public function complete(CompletionInput $input, CompletionSuggestions $suggestions): void
    {
        parent::complete($input, $suggestions);
        if ($input->mustSuggestArgumentValuesFor('task')) {
            $suggestions->suggestValues(array_keys($this->deployer->tasks->all()));
        }
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			/* (c) Anton Medvedev <[email protected]>
6			*
7			* For the full copyright and license information, please view the LICENSE
8			* file that was distributed with this source code.
9			*/
10
11			namespace Deployer\Command;
12
13			use Deployer\Deployer;
14			use Deployer\Task\GroupTask;
15			use Symfony\Component\Console\Command\Command;
16			use Symfony\Component\Console\Completion\CompletionInput;
17			use Symfony\Component\Console\Completion\CompletionSuggestions;
18			use Symfony\Component\Console\Input\InputArgument;
19			use Symfony\Component\Console\Input\InputInterface as Input;
20			use Symfony\Component\Console\Output\OutputInterface as Output;
21
22			class TreeCommand extends Command
23			{
24			/**
25			* @var Output
26			*/
27			protected $output;
28			/**
29			* @var Deployer
30			*/
31			private $deployer;
32			/**
33			* @var array
34			*/
35			private $tree;
36			/**
37			* @var int
38			*/
39			private $depth = 0;
40			/**
41			* @var array
42			*/
43			private $openGroupDepths = [];
44
45			public function __construct(Deployer $deployer)
46			{
47			parent::__construct('tree');
48			$this->setDescription('Display the task-tree for a given task');
49			$this->deployer = $deployer;
50			$this->tree = [];
51			}
52
53			protected function configure()
54			{
55			$this->addArgument(
56			'task',
57			InputArgument::REQUIRED,
58			'Task to display the tree for',
59			);
60			}
61
62			protected function execute(Input $input, Output $output): int
63			{
64			$this->output = $output;
65
66			$rootTaskName = $input->getArgument('task');
67
68			$this->buildTree($rootTaskName);
69			$this->outputTree($rootTaskName);
70			return 0;
71			}
72
73			private function buildTree(string $taskName)
74			{
75			$this->createTreeFromTaskName($taskName, '', true);
76			}
77
78			private function createTreeFromTaskName(string $taskName, string $postfix = '', bool $isLast = false)
79			{
80			$task = $this->deployer->tasks->get($taskName);
81
82			if (!$task->isEnabled()) {
83			if (empty($postfix)) {
84			$postfix = ' // disabled';
85			} else {
86			$postfix .= '; disabled';
87			}
88			}
89
90			if ($task->getBefore()) {
91			$beforePostfix = sprintf(" // before %s", $task->getName());
92
93			foreach ($task->getBefore() as $beforeTask) {
94			$this->createTreeFromTaskName($beforeTask, $beforePostfix);
95			}
96			}
97
98			if ($task instanceof GroupTask) {
99			$isLast = $isLast && empty($task->getAfter());
100
101			$this->addTaskToTree($task->getName() . $postfix, $isLast);
102
103			if (!$isLast) {
104			$this->openGroupDepths[] = $this->depth;
105			}
106
107			$this->depth++;
108
109			$taskGroup = $task->getGroup();
110			foreach ($taskGroup as $subtask) {
111			$isLastSubtask = $subtask === end($taskGroup);
112			$this->createTreeFromTaskName($subtask, '', $isLastSubtask);
113			}
114
115			if (!$isLast) {
116			array_pop($this->openGroupDepths);
117			}
118
119			$this->depth--;
120			} else {
121			$this->addTaskToTree($task->getName() . $postfix, $isLast);
122			}
123
124			if ($task->getAfter()) {
125			$afterPostfix = sprintf(" // after %s", $task->getName());
126
127			foreach ($task->getAfter() as $afterTask) {
128			$this->createTreeFromTaskName($afterTask, $afterPostfix);
129			}
130			}
131			}
132
133			private function addTaskToTree(string $taskName, bool $isLast = false)
134			{
135			$this->tree[] = [
136			'taskName' => $taskName,
137			'depth' => $this->depth,
138			'isLast' => $isLast,
139			'openDepths' => $this->openGroupDepths,
140			];
141			}
142
143			private function outputTree(string $taskName)
144			{
145			$this->output->writeln("The task-tree for <info>$taskName</info>:");
146
147			/**
148			* @var int number of spaces for each depth increase
149			*/
150			$REPEAT_COUNT = 4;
151
152			foreach ($this->tree as $treeItem) {
153			$depth = $treeItem['depth'];
154
155			$startSymbol = $treeItem['isLast'] \|\| $treeItem === end($this->tree) ? '└' : '├';
156
157			$prefix = '';
158
159			for ($i = 0; $i < $depth; $i++) {
160			if (in_array($i, $treeItem['openDepths'])) {
161			$prefix .= '│' . str_repeat(' ', $REPEAT_COUNT - 1);
162			} else {
163			$prefix .= str_repeat(' ', $REPEAT_COUNT);
164			}
165			}
166
167			$prefix .= $startSymbol . '──';
168
169			$this->output->writeln(sprintf('%s %s', $prefix, $treeItem['taskName']));
170			}
171			}
172
173			public function complete(CompletionInput $input, CompletionSuggestions $suggestions): void
174			{
175			parent::complete($input, $suggestions);
176			if ($input->mustSuggestArgumentValuesFor('task')) {
177			$suggestions->suggestValues(array_keys($this->deployer->tasks->all()));
178			}
179			}
180			}
181

deployphp / deployer

GitHub Access Token became invalid

TreeCommand::createTreeFromTaskName() C last analyzed 2025-06-04 13:17 UTC

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like

TreeCommand::createTreeFromTaskName() C
last analyzed 2025-06-04 13:17 UTC