Command::param() - Code Metrics - Inspection of "feat: ajout de nouvelles commandes" - blitz-php/framework - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — main ( 93c2a6...737a66 )

by Dimitri

created 2024-03-27 18:38 UTC

Command::param() A

↳ Parent: Command

Complexity

Conditions	1
Paths	1

Size

Total Lines	5
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

Metric	Value
cc	1
eloc	2
c	0
b	0
f	0
nc	1
nop	2
dl	0
loc	5
ccs	0
cts	2
cp	0
crap	2
rs	10

<?php

/**
 * This file is part of Blitz PHP framework.
 *
 * (c) 2022 Dimitri Sitchet Tomkeu <[email protected]>
 *
 * For the full copyright and license information, please view
 * the LICENSE file that was distributed with this source code.
 */

namespace BlitzPHP\Cli\Console;

use Ahc\Cli\Helper\Terminal;
use Ahc\Cli\Input\Reader;
use Ahc\Cli\IO\Interactor;
use Ahc\Cli\Output\Color;
use Ahc\Cli\Output\Cursor;
use Ahc\Cli\Output\ProgressBar;
use Ahc\Cli\Output\Writer;
use BlitzPHP\Exceptions\CLIException;
use Psr\Log\LoggerInterface;

/**
 * Classe de base utilisée pour créer des commandes pour la console
 *
 * @property string          $alias
 * @property array           $arguments
 * @property string          $description
 * @property string          $group
 * @property LoggerInterface $logger
 * @property string          $name
 * @property array           $options
 * @property array           $required
 * @property string          $service
 * @property bool            $supress
 * @property string          $usage
 * @property string          $version
 */
abstract class Command
{
    /**
     * Le groupe sous lequel la commande est regroupée
     * lors de la liste des commandes.
     *
     * @var string
     */
    protected $group = '';

    /**
     * Le nom de la commande
     *
     * @var string
     */
    protected $name;

    /**
     * La description de l'usage de la commande
     *
     * @var string
     */
    protected $usage = '';

    /**
     * La description courte de la commande
     *
     * @var string
     */
    protected $description = '';

    /**
     * la description des options de la commande
     *
     * @var array
     *
     * @example
     * `[
     *      'option' => [string $description, mixed|null $default_value, callable|null $filter]
     * ]`
     */
    protected $options = [];

    /**
     * La description des arguments de la commande
     *
     * @var array
     *
     * @example
     * `[
     *      'argument' => [string $description, mixed|null $default_value]
     * ]`
     */
    protected $arguments = [];

    /**
     * L'alias de la commande
     *
     * @var string
     */
    protected $alias = '';

    /**
     * La version de la commande
     *
     * @var string
     */
    protected $version = '';

    /**
     * Le nom du service de la commande
     *
     * @var string
     */
    protected $service = '';

    /**
     * Liste des packets requis pour le fonctionnement d'une commande
     * Par exemple, toutes le commande du groupe Database ont besoin de blitz/database
     *
     * @var array
     *
     * @example
     * `[
     *      'vendor/package', 'vendor/package:version'
     * ]`
     */
    protected $required = [];

    /**
     * Defini si on doit supprimer les information du header (nom/version du framework) ou pas
     */
    protected bool $suppress = false;

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

    /**
     * @var Writer
     */
    protected $writer;

    /**
     * @var Reader
     */
    protected $reader;

    /**
     * @var Color
     */
    protected $color;

    /**
     * @var Cursor
     */
    protected $cursor;

    /**
     * @var Terminal
     */
    protected $terminal;

    /**
     * Arguments recus apres executions
     */
    private array $_arguments = [];

    /**
     * Options recus apres executions
     */
    private array $_options = [];

    /**
     * @param Console         $app    Application Console
     * @param LoggerInterface $logger Le Logger à utiliser
     */
    public function __construct(protected Console $app, protected LoggerInterface $logger)
filter:
    dependency_paths: ["lib/*"]
    {
        $this->initProps();
    }

    /**
     * Instance de l'application console
     */
    final public function app(): Console
    {
        return $this->app;
    }

    /**
     * Exécution réelle de la commande.
     *
     * @param array<int|string, string|null> $params
     */
    abstract public function execute(array $params);

    /**
     * Definit les options recues par la commande a l'execution
     *
     * @internal Utiliser seulement par le framework pour fournir les options a la commande
     */
    final public function setOptions(array $options = []): self
    {
        $this->_options = $options;

        return $this;
    }

    /**
     * Definit les arguments recus par la commande a l'execution
     *
     * @internal Utiliser seulement par le framework pour fournir les arguments a la commande
     */
    final public function setArguments(array $arguments = []): self
    {
        $this->_arguments = $arguments;

        return $this;
    }

    /**
     * Recupere la valeur d'un argument lors de l'execution de la commande
     */
    final public function argument(string $name, mixed $default = null): mixed
    {
        return $this->_arguments[$name] ?? $default;
    }

    /**
     * @deprecated 1.1 Utilisez argument() a la place
     */
    final public function getArg(string $name, mixed $default = null)
    {
        return $this->argument($name, $default);
    }

    /**
     * Recupere la valeur d'une option lors de l'execution de la commande
     */
    final public function option(string $name, mixed $default = null): mixed
    {
        return $this->_options[$name] ?? $default;
    }

    /**
     * @deprecated 1.1 Utilisez option() a la place
     */
    final public function getOption(string $name, mixed $default = null)
    {
        return $this->option($name, $default);
    }

    /**
     * Recupere la valeur d'un parametre (option ou argument) lors de l'execution de la commande.
     */
    final public function param(string $name, mixed $default = null): mixed
    {
        $params = array_merge($this->_arguments, $this->_options);

        return $params[$name] ?? $default;
    }

    /**
     * @deprecated 1.1 Utilisez param() a la place
     */
    final public function getParam(string $name, mixed $default = null)
    {
        return $this->param($name, $default);
    }

    /**
     * Ecrit un message dans une couleur spécifique
     */
    final public function colorize(string $message, string $color): self
    {
        $this->writer->colors('<' . $color . '>' . $message . '</end><eol>');

        return $this;
    }

    /**
     * Ecrit un message de reussite
     */
    final public function ok(string $message, bool $eol = false): self
    {
        $this->writer->ok($message, $eol);

        return $this;
    }

    /**
     * Ecrit un message d'echec
     */
    final public function fail(string $message, bool $eol = false): self
    {
        $this->writer->error($message, $eol);

        return $this;
    }

    /**
     * Ecrit un message de succes
     */
    final public function success(string $message, bool $badge = true, string $label = 'SUCCESS'): self
    {
        if (! $badge) {
            $this->writer->okBold($label);
        } else {
            $this->writer->boldWhiteBgGreen(" {$label} ");
        }

        return $this->write(' ' . $message, true);
    }

    /**
     * Ecrit un message d'avertissement
     */
    final public function warning(string $message, bool $badge = true, string $label = 'WARNING'): self
    {
        if (! $badge) {
            $this->writer->warnBold($label);
        } else {
            $this->writer->boldWhiteBgYellow(" {$label} ");
        }

        return $this->write(' ' . $message, true);
    }

    /**
     * Ecrit un message d'information
     */
    final public function info(string $message, bool $badge = true, string $label = 'INFO'): self
    {
        if (! $badge) {
            $this->writer->infoBold($label);
        } else {
            $this->writer->boldWhiteBgCyan(" {$label} ");
        }

        return $this->write(' ' . $message, true);
    }

    /**
     * Ecrit un message d'erreur
     */
    final public function error(string $message, bool $badge = true, string $label = 'ERROR'): self
    {
        if (! $badge) {
            $this->writer->errorBold($label);
        } else {
            $this->writer->boldWhiteBgRed(" {$label} ");
        }

        return $this->write(' ' . $message, true);
    }

    /**
     * Ecrit la tâche actuellement en cours d'execution
     */
    final public function task(string $task, ?int $sleep = null): self
    {
        $this->write('>> ' . $task, true);

        if ($sleep !== null) {
            sleep($sleep);
        }

        return $this;
    }

    /**
     * Écrit EOL n fois.
     */
    final public function eol(int $n = 1): self
    {
        $this->writer->eol($n);

        return $this;
    }

    /**
     * Écrit une nouvelle ligne vide (saut de ligne).
     */
    final public function newLine(): self
    {
        return $this->eol(1);
    }

    /**
     * Générer une table pour la console. Les clés de la première ligne sont prises comme en-tête.
     *
     * @param array[] $rows   Tableau de tableaux associés.
     * @param array   $styles Par exemple : ['head' => 'bold', 'odd' => 'comment', 'even' => 'green']
     */
    final public function table(array $rows, array $styles = []): self
    {
        $this->writer->table($rows, $styles);

        return $this;
    }

    /**
     * Écrit le texte formaté dans stdout ou stderr.
     */
    final public function write(string $texte, bool $eol = false): self
    {
        $this->writer->write($texte, $eol);

        return $this;
    }

    /**
     * Écrit le texte de maniere commentée.
     */
    final public function comment(string $text, bool $eol = false): self
    {
        $this->writer->comment($text, $eol);

        return $this;
    }

    /**
     * Efface la console
     */
    final public function clear(): self
    {
        $this->cursor->clear();

        return $this;
    }

    /**
     * Affiche une bordure en pointillés
     */
    final public function border(?int $length = null, string $char = '-'): self
    {
        $length = $length ?: ($this->terminal->width() ?: 100);
        $str = str_repeat($char, $length);
        $str = substr($str, 0, $length);

        return $this->comment($str, true);
    }

    /**
     * Affiche les donnees formatees en json
     *
     * @param mixed $data
     */
    final public function json($data): self
    {
        $this->write(json_encode($data, JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES), true);

        return $this;
    }

    /**
     * Effectue des tabulations
     */
    final public function tab(int $repeat = 1): self
    {
        $this->write(str_repeat("\t", $repeat));

        return $this;
    }

    /**
     * Laissez l'utilisateur faire un choix parmi les choix disponibles.
     *
     * @param string $text    Texte d'invite.
     * @param array  $choices Choix possibles pour l'utilisateur.
     * @param mixed  $default Valeur par défaut - si non choisie ou invalide.
     * @param bool   $case    Si l'entrée utilisateur doit être sensible à la casse.
     *
     * @return mixed Entrée utilisateur ou valeur par défaut.
     */
    final public function choice(string $text, array $choices, $default = null, bool $case = false): mixed
    {
        return $this->io->choice($text, $choices, $default, $case);
    }

    /**
     * Laissez l'utilisateur faire plusieurs choix parmi les choix disponibles.
     *
     * @param string $text    Texte d'invite.
     * @param array  $choices Choix possibles pour l'utilisateur.
     * @param mixed  $default Valeur par défaut - si non choisie ou invalide.
     * @param bool   $case    Si l'entrée utilisateur doit être sensible à la casse.
     *
     * @return mixed Entrée utilisateur ou valeur par défaut.
     */
    final public function choices(string $text, array $choices, $default = null, bool $case = false): mixed
    {
        return $this->io->choices($text, $choices, $default, $case);
    }

    /**
     * Confirme si l'utilisateur accepte une question posée par le texte donné.
     *
     * @param string $default `y|n`
     */
    final public function confirm(string $text, string $default = 'y'): bool
    {
        return $this->io->confirm($text, $default);
    }

    /**
     * Demander à l'utilisateur d'entrer une donnée
     *
     * @param callable|null $fn      L'assainisseur/validateur pour l'entrée utilisateur
     *                               Tout message d'exception est imprimé et démandé à nouveau.
     * @param int           $retry   Combien de fois encore pour réessayer en cas d'échec.
     * @param mixed|null    $default
     */
    final public function prompt(string $text, $default = null, ?callable $fn = null, int $retry = 3): mixed
    {
        return $this->io->prompt($text, $default, $fn, $retry);
    }

    /**
     * Demander à l'utilisateur une entrée secrète comme un mot de passe. Actuellement pour unix uniquement.
     *
     * @param callable|null $fn    L'assainisseur/validateur pour l'entrée utilisateur
     *                             Tout message d'exception est imprimé en tant qu'erreur.
     * @param int           $retry Combien de fois encore pour réessayer en cas d'échec.
     */
    final public function promptHidden(string $text, ?callable $fn = null, int $retry = 3): mixed
    {
        return $this->io->promptHidden($text, $fn, $retry);
    }

    /**
     * Peut etre utiliser par la commande pour executer d'autres commandes.
     *
     * @return mixed
     *
     * @throws CLIException
     */
    final public function call(string $command, array $arguments = [], array $options = [])
    {
        return $this->app->call($command, $arguments, $options);
    }

    /**
     * Peut etre utiliser par la commande pour verifier si une commande existe dans la liste des commandes enregistrees
     */
    final public function commandExists(string $commandName): bool
    {
        return $this->app->commandExists($commandName);
    }

    /**
     * Initialise une bar de progression
     */
    final public function progress(?int $total = null): ProgressBar
    {
        return new ProgressBar($total, $this->writer);
    }

	/**
	 * Ecrit deux textes de maniere justifiee dans la console (l'un a droite, l'autre a gauche)
	 */
    final public function justify(string $first, ?string $second = '', array $options = []): self
    {
        $options = [
            'first'  => $options['first'] ?? [],
            'second' => ($options['second'] ?? []) + ['bold' => 1],
            'sep'    => (string) ($options['sep'] ?? '.'),
        ];

        $second = trim((string) $second);
        $first  = trim($first);

        $firstLength  = strlen($first);
        $secondLength = strlen($second);

        if (preg_match('/^\\x1b(?:.+)m(.+)\\x1b(?:.+)m$/', $first, $matches)) {
            $firstLength = strlen($matches[1]);
        }
        if (preg_match('/^\\x1b(?:.+)m(.+)\\x1b(?:.+)m$/', $second, $matches)) {
            $secondLength = strlen($matches[1]);
        }

        $dashWidth = ($this->terminal->width() ?: 100) - ($firstLength + $secondLength);
        $dashWidth -= $second === '' ? 1 : 2;

        $first = $this->color->line($first, $options['first']);
        if ($second !== '') {
            $second = $this->color->line($second, $options['second']);
        }

        return $this->write($first . ' ' . str_repeat((string) $options['sep'], $dashWidth) . ' ' . $second)->eol();
    }

	/**
	 * Ecrit un texte au centre de la console
	 */
    final public function center(string $text, array $options = []): self
    {
        $sep = $options['sep'] ?? ' ';
        unset($options['sep']);

        $dashWidth = ($this->terminal->width() ?: 100) - strlen($text);
        $dashWidth -= 2;
        $dashWidth = (int) ($dashWidth / 2);

        $text = $this->color->line($text, $options);
        $repeater = str_repeat($sep, $dashWidth);

        return $this->write($repeater . ' ' . $text . ' ' . $repeater)->eol();
    }

    /**
     * Facilite l'accès à nos propriétés protégées.
     *
     * @return mixed
     */
    public function __get(string $key)
    {
        return $this->{$key} ?? null;
    }

    /**
     * Facilite la vérification de nos propriétés protégées.
     */
    public function __isset(string $key): bool
    {
        return isset($this->{$key});
    }

    /**
     * Initalisation des proprieté necessaires
     *
     * @return void
     */
    private function initProps()
    {
        $this->io       = $this->app->io();
        $this->writer   = $this->io->writer();
        $this->reader   = $this->io->reader();
        $this->color    = $this->writer->colorizer();
        $this->cursor   = $this->writer->cursor();
        $this->terminal = new Terminal();
    }
}


1		<?php
2
3		/**
4		* This file is part of Blitz PHP framework.
5		*
6		* (c) 2022 Dimitri Sitchet Tomkeu <[email protected]>
7		*
8		* For the full copyright and license information, please view
9		* the LICENSE file that was distributed with this source code.
10		*/
11
12		namespace BlitzPHP\Cli\Console;
13
14		use Ahc\Cli\Helper\Terminal;
15		use Ahc\Cli\Input\Reader;
16		use Ahc\Cli\IO\Interactor;
17		use Ahc\Cli\Output\Color;
18		use Ahc\Cli\Output\Cursor;
19		use Ahc\Cli\Output\ProgressBar;
20		use Ahc\Cli\Output\Writer;
21		use BlitzPHP\Exceptions\CLIException;
22		use Psr\Log\LoggerInterface;
23
24		/**
25		* Classe de base utilisée pour créer des commandes pour la console
26		*
27		* @property string $alias
28		* @property array $arguments
29		* @property string $description
30		* @property string $group
31		* @property LoggerInterface $logger
32		* @property string $name
33		* @property array $options
34		* @property array $required
35		* @property string $service
36		* @property bool $supress
37		* @property string $usage
38		* @property string $version
39		*/
40		abstract class Command
41		{
42		/**
43		* Le groupe sous lequel la commande est regroupée
44		* lors de la liste des commandes.
45		*
46		* @var string
47		*/
48		protected $group = '';
49
50		/**
51		* Le nom de la commande
52		*
53		* @var string
54		*/
55		protected $name;
56
57		/**
58		* La description de l'usage de la commande
59		*
60		* @var string
61		*/
62		protected $usage = '';
63
64		/**
65		* La description courte de la commande
66		*
67		* @var string
68		*/
69		protected $description = '';
70
71		/**
72		* la description des options de la commande
73		*
74		* @var array
75		*
76		* @example
77		* `[
78		* 'option' => [string $description, mixed\|null $default_value, callable\|null $filter]
79		* ]`
80		*/
81		protected $options = [];
82
83		/**
84		* La description des arguments de la commande
85		*
86		* @var array
87		*
88		* @example
89		* `[
90		* 'argument' => [string $description, mixed\|null $default_value]
91		* ]`
92		*/
93		protected $arguments = [];
94
95		/**
96		* L'alias de la commande
97		*
98		* @var string
99		*/
100		protected $alias = '';
101
102		/**
103		* La version de la commande
104		*
105		* @var string
106		*/
107		protected $version = '';
108
109		/**
110		* Le nom du service de la commande
111		*
112		* @var string
113		*/
114		protected $service = '';
115
116		/**
117		* Liste des packets requis pour le fonctionnement d'une commande
118		* Par exemple, toutes le commande du groupe Database ont besoin de blitz/database
119		*
120		* @var array
121		*
122		* @example
123		* `[
124		* 'vendor/package', 'vendor/package:version'
125		* ]`
126		*/
127		protected $required = [];
128
129		/**
130		* Defini si on doit supprimer les information du header (nom/version du framework) ou pas
131		*/
132		protected bool $suppress = false;
133
134		/**
135		* @var Interactor
136		*/
137		protected $io;
138
139		/**
140		* @var Writer
141		*/
142		protected $writer;
143
144		/**
145		* @var Reader
146		*/
147		protected $reader;
148
149		/**
150		* @var Color
151		*/
152		protected $color;
153
154		/**
155		* @var Cursor
156		*/
157		protected $cursor;
158
159		/**
160		* @var Terminal
161		*/
162		protected $terminal;
163
164		/**
165		* Arguments recus apres executions
166		*/
167		private array $_arguments = [];
168
169		/**
170		* Options recus apres executions
171		*/
172		private array $_options = [];
173
174		/**
175		* @param Console $app Application Console
176		* @param LoggerInterface $logger Le Logger à utiliser
177		*/
178		public function __construct(protected Console $app, protected LoggerInterface $logger)
		0 ignored issues – show Bug introduced 2022-10-12 12:27 UTC by Report Bug Copy Issue Report The type `BlitzPHP\Cli\Console\Console` was not found. Maybe you did not declare it correctly or list all dependencies? The issue could also be caused by a filter entry in the build configuration. If the path has been excluded in your configuration, e.g. `excluded_paths: ["lib/"]`, you can move it to the dependency path list as follows: filter: dependency_paths: ["lib/"] For further information see https://scrutinizer-ci.com/docs/tools/php/php-scrutinizer/#list-dependency-paths Loading history...
179		{
180	2	$this->initProps();
181		}
182
183		/**
184		* Instance de l'application console
185		*/
186		final public function app(): Console
187		{
188		return $this->app;
189		}
190
191		/**
192		* Exécution réelle de la commande.
193		*
194		* @param array<int\|string, string\|null> $params
195		*/
196		abstract public function execute(array $params);
197
198		/**
199		* Definit les options recues par la commande a l'execution
200		*
201		* @internal Utiliser seulement par le framework pour fournir les options a la commande
202		*/
203		final public function setOptions(array $options = []): self
204		{
205	2	$this->_options = $options;
206
207	2	return $this;
208		}
209
210		/**
211		* Definit les arguments recus par la commande a l'execution
212		*
213		* @internal Utiliser seulement par le framework pour fournir les arguments a la commande
214		*/
215		final public function setArguments(array $arguments = []): self
216		{
217	2	$this->_arguments = $arguments;
218
219	2	return $this;
220		}
221
222		/**
223		* Recupere la valeur d'un argument lors de l'execution de la commande
224		*/
225		final public function argument(string $name, mixed $default = null): mixed
226		{
227		return $this->_arguments[$name] ?? $default;
228		}
229
230		/**
231		* @deprecated 1.1 Utilisez argument() a la place
232		*/
233		final public function getArg(string $name, mixed $default = null)
234		{
235		return $this->argument($name, $default);
236		}
237
238		/**
239		* Recupere la valeur d'une option lors de l'execution de la commande
240		*/
241		final public function option(string $name, mixed $default = null): mixed
242		{
243	2	return $this->_options[$name] ?? $default;
244		}
245
246		/**
247		* @deprecated 1.1 Utilisez option() a la place
248		*/
249		final public function getOption(string $name, mixed $default = null)
250		{
251		return $this->option($name, $default);
252		}
253
254		/**
255		* Recupere la valeur d'un parametre (option ou argument) lors de l'execution de la commande.
256		*/
257		final public function param(string $name, mixed $default = null): mixed
258		{
259		$params = array_merge($this->_arguments, $this->_options);
260
261		return $params[$name] ?? $default;
262		}
263
264		/**
265		* @deprecated 1.1 Utilisez param() a la place
266		*/
267		final public function getParam(string $name, mixed $default = null)
268		{
269		return $this->param($name, $default);
270		}
271
272		/**
273		* Ecrit un message dans une couleur spécifique
274		*/
275		final public function colorize(string $message, string $color): self
276		{
277		$this->writer->colors('<' . $color . '>' . $message . '</end><eol>');
278
279		return $this;
280		}
281
282		/**
283		* Ecrit un message de reussite
284		*/
285		final public function ok(string $message, bool $eol = false): self
286		{
287		$this->writer->ok($message, $eol);
288
289		return $this;
290		}
291
292		/**
293		* Ecrit un message d'echec
294		*/
295		final public function fail(string $message, bool $eol = false): self
296		{
297		$this->writer->error($message, $eol);
298
299		return $this;
300		}
301
302		/**
303		* Ecrit un message de succes
304		*/
305		final public function success(string $message, bool $badge = true, string $label = 'SUCCESS'): self
306		{
307		if (! $badge) {
308	2	$this->writer->okBold($label);
309		} else {
310	2	$this->writer->boldWhiteBgGreen(" {$label} ");
311		}
312
313	2	return $this->write(' ' . $message, true);
314		}
315
316		/**
317		* Ecrit un message d'avertissement
318		*/
319		final public function warning(string $message, bool $badge = true, string $label = 'WARNING'): self
320		{
321		if (! $badge) {
322		$this->writer->warnBold($label);
323		} else {
324		$this->writer->boldWhiteBgYellow(" {$label} ");
325		}
326
327		return $this->write(' ' . $message, true);
328		}
329
330		/**
331		* Ecrit un message d'information
332		*/
333		final public function info(string $message, bool $badge = true, string $label = 'INFO'): self
334		{
335		if (! $badge) {
336		$this->writer->infoBold($label);
337		} else {
338		$this->writer->boldWhiteBgCyan(" {$label} ");
339		}
340
341		return $this->write(' ' . $message, true);
342		}
343
344		/**
345		* Ecrit un message d'erreur
346		*/
347		final public function error(string $message, bool $badge = true, string $label = 'ERROR'): self
348		{
349		if (! $badge) {
350		$this->writer->errorBold($label);
351		} else {
352		$this->writer->boldWhiteBgRed(" {$label} ");
353		}
354
355		return $this->write(' ' . $message, true);
356		}
357
358		/**
359		* Ecrit la tâche actuellement en cours d'execution
360		*/
361		final public function task(string $task, ?int $sleep = null): self
362		{
363	2	$this->write('>> ' . $task, true);
364
365		if ($sleep !== null) {
366	2	sleep($sleep);
367		}
368
369	2	return $this;
370		}
371
372		/**
373		* Écrit EOL n fois.
374		*/
375		final public function eol(int $n = 1): self
376		{
377	2	$this->writer->eol($n);
378
379	2	return $this;
380		}
381
382		/**
383		* Écrit une nouvelle ligne vide (saut de ligne).
384		*/
385		final public function newLine(): self
386		{
387		return $this->eol(1);
388		}
389
390		/**
391		* Générer une table pour la console. Les clés de la première ligne sont prises comme en-tête.
392		*
393		* @param array[] $rows Tableau de tableaux associés.
394		* @param array $styles Par exemple : ['head' => 'bold', 'odd' => 'comment', 'even' => 'green']
395		*/
396		final public function table(array $rows, array $styles = []): self
397		{
398		$this->writer->table($rows, $styles);
399
400		return $this;
401		}
402
403		/**
404		* Écrit le texte formaté dans stdout ou stderr.
405		*/
406		final public function write(string $texte, bool $eol = false): self
407		{
408	2	$this->writer->write($texte, $eol);
409
410	2	return $this;
411		}
412
413		/**
414		* Écrit le texte de maniere commentée.
415		*/
416		final public function comment(string $text, bool $eol = false): self
417		{
418		$this->writer->comment($text, $eol);
419
420		return $this;
421		}
422
423		/**
424		* Efface la console
425		*/
426		final public function clear(): self
427		{
428		$this->cursor->clear();
429
430		return $this;
431		}
432
433		/**
434		* Affiche une bordure en pointillés
435		*/
436		final public function border(?int $length = null, string $char = '-'): self
437		{
438		$length = $length ?: ($this->terminal->width() ?: 100);
439		$str = str_repeat($char, $length);
440		$str = substr($str, 0, $length);
441
442		return $this->comment($str, true);
443		}
444
445		/**
446		* Affiche les donnees formatees en json
447		*
448		* @param mixed $data
449		*/
450		final public function json($data): self
451		{
452		$this->write(json_encode($data, JSON_PRETTY_PRINT \| JSON_UNESCAPED_SLASHES), true);
453
454		return $this;
455		}
456
457		/**
458		* Effectue des tabulations
459		*/
460		final public function tab(int $repeat = 1): self
461		{
462		$this->write(str_repeat("\t", $repeat));
463
464		return $this;
465		}
466
467		/**
468		* Laissez l'utilisateur faire un choix parmi les choix disponibles.
469		*
470		* @param string $text Texte d'invite.
471		* @param array $choices Choix possibles pour l'utilisateur.
472		* @param mixed $default Valeur par défaut - si non choisie ou invalide.
473		* @param bool $case Si l'entrée utilisateur doit être sensible à la casse.
474		*
475		* @return mixed Entrée utilisateur ou valeur par défaut.
476		*/
477		final public function choice(string $text, array $choices, $default = null, bool $case = false): mixed
478		{
479		return $this->io->choice($text, $choices, $default, $case);
480		}
481
482		/**
483		* Laissez l'utilisateur faire plusieurs choix parmi les choix disponibles.
484		*
485		* @param string $text Texte d'invite.
486		* @param array $choices Choix possibles pour l'utilisateur.
487		* @param mixed $default Valeur par défaut - si non choisie ou invalide.
488		* @param bool $case Si l'entrée utilisateur doit être sensible à la casse.
489		*
490		* @return mixed Entrée utilisateur ou valeur par défaut.
491		*/
492		final public function choices(string $text, array $choices, $default = null, bool $case = false): mixed
493		{
494		return $this->io->choices($text, $choices, $default, $case);
495		}
496
497		/**
498		* Confirme si l'utilisateur accepte une question posée par le texte donné.
499		*
500		* @param string $default `y\|n`
501		*/
502		final public function confirm(string $text, string $default = 'y'): bool
503		{
504		return $this->io->confirm($text, $default);
505		}
506
507		/**
508		* Demander à l'utilisateur d'entrer une donnée
509		*
510		* @param callable\|null $fn L'assainisseur/validateur pour l'entrée utilisateur
511		* Tout message d'exception est imprimé et démandé à nouveau.
512		* @param int $retry Combien de fois encore pour réessayer en cas d'échec.
513		* @param mixed\|null $default
514		*/
515		final public function prompt(string $text, $default = null, ?callable $fn = null, int $retry = 3): mixed
516		{
517		return $this->io->prompt($text, $default, $fn, $retry);
518		}
519
520		/**
521		* Demander à l'utilisateur une entrée secrète comme un mot de passe. Actuellement pour unix uniquement.
522		*
523		* @param callable\|null $fn L'assainisseur/validateur pour l'entrée utilisateur
524		* Tout message d'exception est imprimé en tant qu'erreur.
525		* @param int $retry Combien de fois encore pour réessayer en cas d'échec.
526		*/
527		final public function promptHidden(string $text, ?callable $fn = null, int $retry = 3): mixed
528		{
529		return $this->io->promptHidden($text, $fn, $retry);
530		}
531
532		/**
533		* Peut etre utiliser par la commande pour executer d'autres commandes.
534		*
535		* @return mixed
536		*
537		* @throws CLIException
538		*/
539		final public function call(string $command, array $arguments = [], array $options = [])
540		{
541		return $this->app->call($command, $arguments, $options);
542		}
543
544		/**
545		* Peut etre utiliser par la commande pour verifier si une commande existe dans la liste des commandes enregistrees
546		*/
547		final public function commandExists(string $commandName): bool
548		{
549		return $this->app->commandExists($commandName);
550		}
551
552		/**
553		* Initialise une bar de progression
554		*/
555		final public function progress(?int $total = null): ProgressBar
556		{
557		return new ProgressBar($total, $this->writer);
558		}
559
560		/**
561		* Ecrit deux textes de maniere justifiee dans la console (l'un a droite, l'autre a gauche)
562		*/
563		final public function justify(string $first, ?string $second = '', array $options = []): self
564		{
565		$options = [
566		'first' => $options['first'] ?? [],
567		'second' => ($options['second'] ?? []) + ['bold' => 1],
568		'sep' => (string) ($options['sep'] ?? '.'),
569		];
570
571		$second = trim((string) $second);
572		$first = trim($first);
573
574		$firstLength = strlen($first);
575		$secondLength = strlen($second);
576
577		if (preg_match('/^\\x1b(?:.+)m(.+)\\x1b(?:.+)m$/', $first, $matches)) {
578		$firstLength = strlen($matches[1]);
579		}
580		if (preg_match('/^\\x1b(?:.+)m(.+)\\x1b(?:.+)m$/', $second, $matches)) {
581		$secondLength = strlen($matches[1]);
582		}
583
584		$dashWidth = ($this->terminal->width() ?: 100) - ($firstLength + $secondLength);
585		$dashWidth -= $second === '' ? 1 : 2;
586
587		$first = $this->color->line($first, $options['first']);
588		if ($second !== '') {
589		$second = $this->color->line($second, $options['second']);
590		}
591
592		return $this->write($first . ' ' . str_repeat((string) $options['sep'], $dashWidth) . ' ' . $second)->eol();
593		}
594
595		/**
596		* Ecrit un texte au centre de la console
597		*/
598		final public function center(string $text, array $options = []): self
599		{
600		$sep = $options['sep'] ?? ' ';
601		unset($options['sep']);
602
603		$dashWidth = ($this->terminal->width() ?: 100) - strlen($text);
604		$dashWidth -= 2;
605		$dashWidth = (int) ($dashWidth / 2);
606
607		$text = $this->color->line($text, $options);
608		$repeater = str_repeat($sep, $dashWidth);
609
610		return $this->write($repeater . ' ' . $text . ' ' . $repeater)->eol();
611		}
612
613		/**
614		* Facilite l'accès à nos propriétés protégées.
615		*
616		* @return mixed
617		*/
618		public function __get(string $key)
619		{
620	2	return $this->{$key} ?? null;
621		}
622
623		/**
624		* Facilite la vérification de nos propriétés protégées.
625		*/
626		public function __isset(string $key): bool
627		{
628		return isset($this->{$key});
629		}
630
631		/**
632		* Initalisation des proprieté necessaires
633		*
634		* @return void
635		*/
636		private function initProps()
637		{
638	2	$this->io = $this->app->io();
639	2	$this->writer = $this->io->writer();
640	2	$this->reader = $this->io->reader();
641	2	$this->color = $this->writer->colorizer();
642	2	$this->cursor = $this->writer->cursor();
643	2	$this->terminal = new Terminal();
644		}
645		}
646

blitz-php / framework

Push — main ( 93c2a6...737a66 )

Command::param() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like