AbstractCommand::run() - Code Metrics - Inspection of "feat: new features and drop support of PHP 8.1" - Cecilapp/Cecil - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#2226)

by Arnaud

created 2025-11-23 01:17 UTC

AbstractCommand::run() B

↳ Parent: AbstractCommand

Complexity

Conditions	11
Paths	40

Size

Total Lines	42
Code Lines	24

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	11
eloc	24
nc	40
nop	2
dl	0
loc	42
rs	7.3166
c	0
b	0
f	0

How to fix Complexity

<?php

/**
 * This file is part of Cecil.
 *
 * (c) Arnaud Ligny <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

declare(strict_types=1);

namespace Cecil\Command;

use Cecil\Builder;
use Cecil\Config;
use Cecil\Exception\RuntimeException;
use Cecil\Logger\ConsoleLogger;
use Cecil\Util;
use Joli\JoliNotif\Notification;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\Console\Style\SymfonyStyle;
use Symfony\Component\Filesystem\Path;
use Symfony\Component\Process\Process;
use Symfony\Component\Validator\Constraints\Url;
use Symfony\Component\Validator\Validation;

/**
 * Abstract command class.
 *
 * This class provides common functionality for all commands, such as configuration loading, path handling, and error management.
 */
class AbstractCommand extends Command
{
    public const CONFIG_FILE = ['cecil.yml', 'config.yml'];
    public const TMP_DIR = '.cecil';
    public const EXCLUDED_CMD = ['about', 'new:site', 'self-update'];
    public const SERVE_OUTPUT = '.cecil/preview';

    /** @var Notification */
    public $notification;

    /** @var InputInterface */
    protected $input;

    /** @var OutputInterface */
    protected $output;

    /** @var SymfonyStyle */
    protected $io;

    /** @var string */
    protected $rootPath;

    /** @var null|string */
    private $path = null;

    /** @var array */
    private $configFiles = [];

    /** @var Config */
    private $config;

    /** @var Builder */
    private $builder;

    /**
     * {@inheritdoc}
     */
    protected function initialize(InputInterface $input, OutputInterface $output)
    {
        $this->input = $input;
        $this->output = $output;
        $this->io = new SymfonyStyle($input, $output);
        $this->rootPath = Util\Platform::isPhar() ? Util\Platform::getPharPath() . '/' : realpath(Util::joinFile(__DIR__, '/../../'));

        // prepare configuration files list
        if (!\in_array($this->getName(), self::EXCLUDED_CMD)) {
            // site config file
            $this->configFiles[$this->locateConfigFile($this->getPath())['name']] = $this->locateConfigFile($this->getPath())['path'];
            // additional config file(s) from --config=<file>
            if ($input->hasOption('config') && $input->getOption('config') !== null) {
                $this->configFiles += $this->locateAdditionalConfigFiles($this->getPath(), (string) $input->getOption('config'));
            }
            // checks file(s)
            $this->configFiles = array_unique($this->configFiles);
            foreach ($this->configFiles as $fileName => $filePath) {
                if ($filePath === false) {
                    unset($this->configFiles[$fileName]);
                    $this->io->warning(\sprintf('Could not find configuration file "%s".', $fileName));
                }
            }
        }
        // prepare notification
        $this->notification = (new Notification())
            ->setTitle('Cecil')
            ->setIcon('./resources/icon.png')
            ->setBody('Notification from Cecil static site generator.')
        ;

        parent::initialize($input, $output);
    }

    /**
     * {@inheritdoc}
     */
    public function run(InputInterface $input, OutputInterface $output): int
    {
        // disable debug mode if a verbosity level is specified
        if ($output->getVerbosity() != OutputInterface::VERBOSITY_NORMAL) {
            putenv('CECIL_DEBUG=false');
        }
        // force verbosity level to "debug" in debug mode
        if (getenv('CECIL_DEBUG') == 'true') {
            $output->setVerbosity(OutputInterface::VERBOSITY_DEBUG);
        }
        if ($output->isDebug()) {
            // set env. variable in debug mode
            putenv('CECIL_DEBUG=true');

            return parent::run($input, $output);
        }
        // run with human error message
        try {
            return parent::run($input, $output);
        } catch (\Exception $e) {
            if ($this->io === null) {
                $this->io = new SymfonyStyle($input, $output);
            }
            $message = '';
            $i = 0;
            do {
                //if ($e instanceof \Twig\Error\RuntimeError) {
                //    continue;
                //}

                if ($i > 0) {
                    $message .= '└ ';
                }
                $message .= "{$e->getMessage()}\n";
                if ($e->getFile() && $e instanceof RuntimeException) {
                    $message .= \sprintf("→ %s%s\n", $e->getFile(), $e->getLine() ? ":{$e->getLine()}" : '');
                }
                $i++;
            } while ($e = $e->getPrevious());
            $this->io->error($message);

            exit(1);
        }
    }

    /**
     * Returns the working path.
     */
    protected function getPath(bool $exist = true): ?string
    {
        if ($this->path === null) {
            try {
                // get working directory by default
                if (false === $this->path = getcwd()) {
                    throw new \Exception('Unable to get current working directory.');
                }
                // ... or path
                if ($this->input->getArgument('path') !== null) {
                    $this->path = Path::canonicalize($this->input->getArgument('path'));
                }
                // try to get canonicalized absolute path
                if ($exist) {
                    if (realpath($this->path) === false) {
                        throw new \Exception(\sprintf('The given path "%s" is not valid.', $this->path));
                    }
                    $this->path = realpath($this->path);
                }
            } catch (\Exception $e) {
                throw new \Exception($e->getMessage());
            }
        }

        return $this->path;
    }

    /**
     * Returns config file(s) path.
     */
    protected function getConfigFiles(): array
    {
        return $this->configFiles ?? [];
    }

    /**
     * Creates or returns a Builder instance.
     *
     * @throws RuntimeException
     */
    protected function getBuilder(array $config = []): Builder
    {
        try {
            // loads configuration files if not already done
            if ($this->config === null) {
                $this->config = new Config();
                // loads and merges configuration files
                foreach ($this->getConfigFiles() as $filePath) {
                    $this->config->import($this->config::loadFile($filePath), Config::IMPORT_MERGE);
                }
                // merges configuration from $config parameter
                $this->config->import($config, Config::IMPORT_MERGE);
            }
            // creates builder instance if not already done
            if ($this->builder === null) {
                $this->builder = (new Builder($this->config, new ConsoleLogger($this->output)))
                    ->setSourceDir($this->getPath())
                    ->setDestinationDir($this->getPath());
            }
        } catch (\Exception $e) {
            throw new RuntimeException($e->getMessage());
        }

        return $this->builder;
    }

    /**
     * Locates the configuration in the given path, as an array of the file name and path, if file exists, otherwise default name and false.
     */
    protected function locateConfigFile(string $path): array
    {
        $config = [
            'name' => self::CONFIG_FILE[0],
            'path' => false,
        ];
        foreach (self::CONFIG_FILE as $configFileName) {
            if (($configFilePath = realpath(Util::joinFile($path, $configFileName))) !== false) {
                $config = [
                    'name' => $configFileName,
                    'path' => $configFilePath,
                ];
            }
        }

        return $config;
    }

    /**
     * Locates additional configuration file(s) from the given list of files, relative to the given path or absolute.
     */
    protected function locateAdditionalConfigFiles(string $path, string $configFilesList): array
    {
        $config = [];
        foreach (explode(',', $configFilesList) as $filename) {
            // absolute path
            $config[$filename] = realpath($filename);
            // relative path
            if (!Util\File::getFS()->isAbsolutePath($filename)) {
                $config[$filename] = realpath(Util::joinFile($path, $filename));
            }
        }

        return $config;
    }

    /**
     * Opens path with editor.
     *
     * @throws RuntimeException
     */
    protected function openEditor(string $path, string $editor): void
    {
        $command = \sprintf('%s "%s"', $editor, $path);
        switch (Util\Platform::getOS()) {
            case Util\Platform::OS_WIN:
                $command = \sprintf('start /B "" %s "%s"', $editor, $path);
                break;
            case Util\Platform::OS_OSX:
                // Typora on macOS
                if ($editor == 'typora') {
                    $command = \sprintf('open -a typora "%s"', $path);
                }
                break;
        }
        $process = Process::fromShellCommandline($command);
        $process->run();
        if (!$process->isSuccessful()) {
            throw new RuntimeException(\sprintf('Unable to use "%s" editor.', $editor));
        }
    }

    /**
     * Validate URL.
     *
     * @throws RuntimeException
     */
    public static function validateUrl(string $url): string
    {
        if ($url == '/') { // tolerate root URL
            return $url;
        }
        $validator = Validation::createValidator();
        $violations = $validator->validate($url, new Url());
        if (\count($violations) > 0) {
            foreach ($violations as $violation) {
                throw new RuntimeException($violation->getMessage());
            }
        }
        return rtrim($url, '/') . '/';
    }

    /**
     * Returns the "binary name" in the console context.
     */
    protected function binName(): string
    {
        return basename($_SERVER['argv'][0]);
    }

    /**
     * Override default help message.
     *
     * @return string
     */
    public function getProcessedHelp(): string
    {
        $name = $this->getName();
        $placeholders = [
            '%command.name%',
            '%command.full_name%',
        ];
        $replacements = [
            $name,
            $this->binName() . ' ' . $name,
        ];

        return str_replace($placeholders, $replacements, $this->getHelp() ?: $this->getDescription());
    }
}


1			<?php
2
3			/**
4			* This file is part of Cecil.
5			*
6			* (c) Arnaud Ligny <[email protected]>
7			*
8			* For the full copyright and license information, please view the LICENSE
9			* file that was distributed with this source code.
10			*/
11
12			declare(strict_types=1);
13
14			namespace Cecil\Command;
15
16			use Cecil\Builder;
17			use Cecil\Config;
18			use Cecil\Exception\RuntimeException;
19			use Cecil\Logger\ConsoleLogger;
20			use Cecil\Util;
21			use Joli\JoliNotif\Notification;
22			use Symfony\Component\Console\Command\Command;
23			use Symfony\Component\Console\Input\InputInterface;
24			use Symfony\Component\Console\Output\OutputInterface;
25			use Symfony\Component\Console\Style\SymfonyStyle;
26			use Symfony\Component\Filesystem\Path;
27			use Symfony\Component\Process\Process;
28			use Symfony\Component\Validator\Constraints\Url;
29			use Symfony\Component\Validator\Validation;
30
31			/**
32			* Abstract command class.
33			*
34			* This class provides common functionality for all commands, such as configuration loading, path handling, and error management.
35			*/
36			class AbstractCommand extends Command
37			{
38			public const CONFIG_FILE = ['cecil.yml', 'config.yml'];
39			public const TMP_DIR = '.cecil';
40			public const EXCLUDED_CMD = ['about', 'new:site', 'self-update'];
41			public const SERVE_OUTPUT = '.cecil/preview';
42
43			/** @var Notification */
44			public $notification;
45
46			/** @var InputInterface */
47			protected $input;
48
49			/** @var OutputInterface */
50			protected $output;
51
52			/** @var SymfonyStyle */
53			protected $io;
54
55			/** @var string */
56			protected $rootPath;
57
58			/** @var null\|string */
59			private $path = null;
60
61			/** @var array */
62			private $configFiles = [];
63
64			/** @var Config */
65			private $config;
66
67			/** @var Builder */
68			private $builder;
69
70			/**
71			* {@inheritdoc}
72			*/
73			protected function initialize(InputInterface $input, OutputInterface $output)
74			{
75			$this->input = $input;
76			$this->output = $output;
77			$this->io = new SymfonyStyle($input, $output);
78			$this->rootPath = Util\Platform::isPhar() ? Util\Platform::getPharPath() . '/' : realpath(Util::joinFile(__DIR__, '/../../'));
79
80			// prepare configuration files list
81			if (!\in_array($this->getName(), self::EXCLUDED_CMD)) {
82			// site config file
83			$this->configFiles[$this->locateConfigFile($this->getPath())['name']] = $this->locateConfigFile($this->getPath())['path'];
84			// additional config file(s) from --config=<file>
85			if ($input->hasOption('config') && $input->getOption('config') !== null) {
86			$this->configFiles += $this->locateAdditionalConfigFiles($this->getPath(), (string) $input->getOption('config'));
87			}
88			// checks file(s)
89			$this->configFiles = array_unique($this->configFiles);
90			foreach ($this->configFiles as $fileName => $filePath) {
91			if ($filePath === false) {
92			unset($this->configFiles[$fileName]);
93			$this->io->warning(\sprintf('Could not find configuration file "%s".', $fileName));
94			}
95			}
96			}
97			// prepare notification
98			$this->notification = (new Notification())
99			->setTitle('Cecil')
100			->setIcon('./resources/icon.png')
101			->setBody('Notification from Cecil static site generator.')
102			;
103
104			parent::initialize($input, $output);
105			}
106
107			/**
108			* {@inheritdoc}
109			*/
110			public function run(InputInterface $input, OutputInterface $output): int
111			{
112			// disable debug mode if a verbosity level is specified
113			if ($output->getVerbosity() != OutputInterface::VERBOSITY_NORMAL) {
114			putenv('CECIL_DEBUG=false');
115			}
116			// force verbosity level to "debug" in debug mode
117			if (getenv('CECIL_DEBUG') == 'true') {
118			$output->setVerbosity(OutputInterface::VERBOSITY_DEBUG);
119			}
120			if ($output->isDebug()) {
121			// set env. variable in debug mode
122			putenv('CECIL_DEBUG=true');
123
124			return parent::run($input, $output);
125			}
126			// run with human error message
127			try {
128			return parent::run($input, $output);
129			} catch (\Exception $e) {
130			if ($this->io === null) {
131			$this->io = new SymfonyStyle($input, $output);
132			}
133			$message = '';
134			$i = 0;
135			do {
136			//if ($e instanceof \Twig\Error\RuntimeError) {
137			// continue;
138			//}
139
140			if ($i > 0) {
141			$message .= '└ ';
142			}
143			$message .= "{$e->getMessage()}\n";
144			if ($e->getFile() && $e instanceof RuntimeException) {
145			$message .= \sprintf("→ %s%s\n", $e->getFile(), $e->getLine() ? ":{$e->getLine()}" : '');
146			}
147			$i++;
148			} while ($e = $e->getPrevious());
149			$this->io->error($message);
150
151			exit(1);
152			}
153			}
154
155			/**
156			* Returns the working path.
157			*/
158			protected function getPath(bool $exist = true): ?string
159			{
160			if ($this->path === null) {
161			try {
162			// get working directory by default
163			if (false === $this->path = getcwd()) {
164			throw new \Exception('Unable to get current working directory.');
165			}
166			// ... or path
167			if ($this->input->getArgument('path') !== null) {
168			$this->path = Path::canonicalize($this->input->getArgument('path'));
169			}
170			// try to get canonicalized absolute path
171			if ($exist) {
172			if (realpath($this->path) === false) {
173			throw new \Exception(\sprintf('The given path "%s" is not valid.', $this->path));
174			}
175			$this->path = realpath($this->path);
176			}
177			} catch (\Exception $e) {
178			throw new \Exception($e->getMessage());
179			}
180			}
181
182			return $this->path;
183			}
184
185			/**
186			* Returns config file(s) path.
187			*/
188			protected function getConfigFiles(): array
189			{
190			return $this->configFiles ?? [];
191			}
192
193			/**
194			* Creates or returns a Builder instance.
195			*
196			* @throws RuntimeException
197			*/
198			protected function getBuilder(array $config = []): Builder
199			{
200			try {
201			// loads configuration files if not already done
202			if ($this->config === null) {
203			$this->config = new Config();
204			// loads and merges configuration files
205			foreach ($this->getConfigFiles() as $filePath) {
206			$this->config->import($this->config::loadFile($filePath), Config::IMPORT_MERGE);
207			}
208			// merges configuration from $config parameter
209			$this->config->import($config, Config::IMPORT_MERGE);
210			}
211			// creates builder instance if not already done
212			if ($this->builder === null) {
213			$this->builder = (new Builder($this->config, new ConsoleLogger($this->output)))
214			->setSourceDir($this->getPath())
215			->setDestinationDir($this->getPath());
216			}
217			} catch (\Exception $e) {
218			throw new RuntimeException($e->getMessage());
219			}
220
221			return $this->builder;
222			}
223
224			/**
225			* Locates the configuration in the given path, as an array of the file name and path, if file exists, otherwise default name and false.
226			*/
227			protected function locateConfigFile(string $path): array
228			{
229			$config = [
230			'name' => self::CONFIG_FILE[0],
231			'path' => false,
232			];
233			foreach (self::CONFIG_FILE as $configFileName) {
234			if (($configFilePath = realpath(Util::joinFile($path, $configFileName))) !== false) {
235			$config = [
236			'name' => $configFileName,
237			'path' => $configFilePath,
238			];
239			}
240			}
241
242			return $config;
243			}
244
245			/**
246			* Locates additional configuration file(s) from the given list of files, relative to the given path or absolute.
247			*/
248			protected function locateAdditionalConfigFiles(string $path, string $configFilesList): array
249			{
250			$config = [];
251			foreach (explode(',', $configFilesList) as $filename) {
252			// absolute path
253			$config[$filename] = realpath($filename);
254			// relative path
255			if (!Util\File::getFS()->isAbsolutePath($filename)) {
256			$config[$filename] = realpath(Util::joinFile($path, $filename));
257			}
258			}
259
260			return $config;
261			}
262
263			/**
264			* Opens path with editor.
265			*
266			* @throws RuntimeException
267			*/
268			protected function openEditor(string $path, string $editor): void
269			{
270			$command = \sprintf('%s "%s"', $editor, $path);
271			switch (Util\Platform::getOS()) {
272			case Util\Platform::OS_WIN:
273			$command = \sprintf('start /B "" %s "%s"', $editor, $path);
274			break;
275			case Util\Platform::OS_OSX:
276			// Typora on macOS
277			if ($editor == 'typora') {
278			$command = \sprintf('open -a typora "%s"', $path);
279			}
280			break;
281			}
282			$process = Process::fromShellCommandline($command);
283			$process->run();
284			if (!$process->isSuccessful()) {
285			throw new RuntimeException(\sprintf('Unable to use "%s" editor.', $editor));
286			}
287			}
288
289			/**
290			* Validate URL.
291			*
292			* @throws RuntimeException
293			*/
294			public static function validateUrl(string $url): string
295			{
296			if ($url == '/') { // tolerate root URL
297			return $url;
298			}
299			$validator = Validation::createValidator();
300			$violations = $validator->validate($url, new Url());
301			if (\count($violations) > 0) {
302			foreach ($violations as $violation) {
303			throw new RuntimeException($violation->getMessage());
304			}
305			}
306			return rtrim($url, '/') . '/';
307			}
308
309			/**
310			* Returns the "binary name" in the console context.
311			*/
312			protected function binName(): string
313			{
314			return basename($_SERVER['argv'][0]);
315			}
316
317			/**
318			* Override default help message.
319			*
320			* @return string
321			*/
322			public function getProcessedHelp(): string
323			{
324			$name = $this->getName();
325			$placeholders = [
326			'%command.name%',
327			'%command.full_name%',
328			];
329			$replacements = [
330			$name,
331			$this->binName() . ' ' . $name,
332			];
333
334			return str_replace($placeholders, $replacements, $this->getHelp() ?: $this->getDescription());
335			}
336			}
337

Cecilapp / Cecil

Pull Request — master (#2226)

AbstractCommand::run() B

Complexity

Size

Duplication

Importance

How to fix Complexity

Long Method

Duplication Side-by-Side

Filter issues like