ConsoleColor::getSequencesFrom() - Code Metrics - Inspection of "wp 29" - alecrabbit/php-console-colour - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( c7da00...5ce46b )

by Alec

created 2019-03-26 12:48 UTC

ConsoleColor::getSequencesFrom() A

↳ Parent: ConsoleColor

Complexity

Conditions	4
Paths	4

Size

Total Lines	28
Code Lines	14

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	13
CRAP Score	4

Importance

Changes

Metric	Value
cc	4
eloc	14
nc	4
nop	1
dl	0
loc	28
ccs	13
cts	13
cp	1
crap	4
rs	9.7998
c	0
b	0
f	0

<?php declare(strict_types=1);

namespace AlecRabbit\ConsoleColour;

use AlecRabbit\ConsoleColour\Contracts\ConsoleColorInterface;
use JakubOnderka\PhpConsoleColor\InvalidStyleException;
use Symfony\Terminal;

class ConsoleColor implements ConsoleColorInterface
{
    /** @var bool */
    protected $isSupported;

    /** @var bool */
    protected $forceStyle = false;

    /** @var array */
    protected $themes = [];

    /** @var bool */
    protected $are256ColorsSupported;

    public function __construct()
    {
        $terminal = new Terminal();
        $this->isSupported = $terminal->supportsColor();
        $this->are256ColorsSupported = $terminal->supports256Color();
    }

    /** {@inheritdoc} */
    public function apply($styles, $text): string
    {
        if (!$this->isStyleForced() && !$this->isSupported()) {
            return $text;
        }

        $sequences =
            $this->getSequencesFrom(
                $this->refineStyles($styles)
            );

        if (empty($sequences)) {
            return $text;
        }

        return $this->applySequences($text, $sequences);
    }

    /** {@inheritdoc} */
    public function isStyleForced(): bool
    {
        return $this->forceStyle;
    }

    /** {@inheritdoc} */
    public function isSupported(): bool
    {
        return $this->isSupported;
    }

    /**
     * @param array $styles
     * @return array
     * @throws InvalidStyleException
     */
    protected function getSequencesFrom(array $styles): array
    {
        $sequences = [[]];

        foreach ($styles as $s) {
            if (isset($this->themes[$s])) {
                $sequences[] = $this->themeSequence($s);
            } elseif ($this->isValidStyle($s)) {
                $sequences[][] = $this->styleSequence($s);
            } else {
                throw new InvalidStyleException($s);
            }
        }

        $sequences =
            \array_filter(
                \array_merge(...$sequences),
                /**
                 * @param mixed $val
                 * @return bool
                 * @psalm-suppress MissingClosureParamType
                 */
                function ($val): bool {
                    return $val !== null;
                }
            );

        return $sequences;
    }

    /**
     * @param string $name
     * @return string[]|null[]
     */
    protected function themeSequence($name): array
    {
        $sequences = [];
        foreach ($this->themes[$name] as $style) {
            $sequences[] = $this->styleSequence($style);
        }
        return $sequences;
    }

    /**
     * @param string $style
     * @return null|string
     */
    protected function styleSequence($style): ?string
    {
        if (\array_key_exists($style, static::STYLES)) {
            return static::STYLES[$style];
        }

        if (!$this->are256ColorsSupported()) {
            return null;
        }

        return
            $this->process256ColorStyle($style);
    }

    /** {@inheritdoc} */
    public function are256ColorsSupported(): bool
    {
        return $this->are256ColorsSupported;
    }

    /**
     * @param string $style
     * @return bool
     */
    protected function isValidStyle($style): bool
    {
        return \array_key_exists($style, static::STYLES) || \preg_match(self::COLOR256_REGEXP, $style);
    }

    /**
     * @param string|array $styles
     * @return array
     */
    protected function refineStyles($styles): array
    {
        if (\is_string($styles)) {
            $styles = [$styles];
        }
        $this->assertStyles($styles);
        return $styles;
    }

    /**
     * @param mixed $styles
     */
    protected function assertStyles($styles): void
    {
        if (!\is_array($styles)) {
            throw new \InvalidArgumentException('Style must be string or array.');
        }
    }

    /**
     * @param string $text
     * @param array $sequences
     * @return string
     */
    protected function applySequences(string $text, array $sequences): string
    {
        return
            $this->escSequence(\implode(';', $sequences)) .
            $text .
            $this->escSequence((string)self::RESET_STYLE);
    }

    /**
     * @param string $value
     * @return string
     */
    protected function escSequence(string $value): string
    {
        return "\033[{$value}m";
    }

    /** {@inheritdoc} */
    public function setForceStyle(bool $forceStyle): void
    {
        $this->forceStyle = $forceStyle;
    }

    /** {@inheritdoc} */
    public function getThemes(): array
    {
        return $this->themes;
    }

    /** {@inheritdoc} */
    public function setThemes(array $themes): void
    {
        $this->themes = [];
        foreach ($themes as $name => $styles) {
            $this->addTheme($name, $styles);
        }
    }

    /** {@inheritdoc} */
    public function addTheme($name, $styles): void
    {
        $styles = $this->refineStyles($styles);

        foreach ($styles as $style) {
            if (!$this->isValidStyle($style)) {
                throw new InvalidStyleException($style);
            }
        }

        $this->themes[$name] = $styles;
    }

    /** {@inheritdoc} */
    public function hasTheme($name): bool
    {
        return isset($this->themes[$name]);
    }

    /** {@inheritdoc} */
    public function removeTheme($name): void
    {
        unset($this->themes[$name]);
    }

    /** {@inheritdoc} */
    public function getPossibleStyles(): array
    {
        return \array_keys(static::STYLES);
    }

    /**
     * @param string $style
     * @return string
     */
    protected function process256ColorStyle(string $style): string
    {
        \preg_match(self::COLOR256_REGEXP, $style, $matches);

        $type = $matches[1] === 'bg_' ? self::BACKGROUND : self::FOREGROUND;
        $value = $matches[2];

        return "$type;5;$value";
    }
}


1		<?php declare(strict_types=1);
2
3		namespace AlecRabbit\ConsoleColour;
4
5		use AlecRabbit\ConsoleColour\Contracts\ConsoleColorInterface;
6		use JakubOnderka\PhpConsoleColor\InvalidStyleException;
7		use Symfony\Terminal;
8
9		class ConsoleColor implements ConsoleColorInterface
10		{
11		/** @var bool */
12		protected $isSupported;
13
14		/** @var bool */
15		protected $forceStyle = false;
16
17		/** @var array */
18		protected $themes = [];
19
20		/** @var bool */
21		protected $are256ColorsSupported;
22
23	71	public function __construct()
24		{
25	71	$terminal = new Terminal();
26	71	$this->isSupported = $terminal->supportsColor();
27	71	$this->are256ColorsSupported = $terminal->supports256Color();
28	71	}
29
30		/** {@inheritdoc} */
31	54	public function apply($styles, $text): string
32		{
33	54	if (!$this->isStyleForced() && !$this->isSupported()) {
34	3	return $text;
35		}
36
37		$sequences =
38	51	$this->getSequencesFrom(
39	51	$this->refineStyles($styles)
40		);
41
42	42	if (empty($sequences)) {
43	6	return $text;
44		}
45
46	36	return $this->applySequences($text, $sequences);
47		}
48
49		/** {@inheritdoc} */
50	57	public function isStyleForced(): bool
51		{
52	57	return $this->forceStyle;
53		}
54
55		/** {@inheritdoc} */
56	1	public function isSupported(): bool
57		{
58	1	return $this->isSupported;
59		}
60
61		/**
62		* @param array $styles
63		* @return array
64		* @throws InvalidStyleException
65		*/
66	48	protected function getSequencesFrom(array $styles): array
67		{
68	48	$sequences = [[]];
69
70	48	foreach ($styles as $s) {
71	48	if (isset($this->themes[$s])) {
72	15	$sequences[] = $this->themeSequence($s);
73	37	} elseif ($this->isValidStyle($s)) {
74	31	$sequences[][] = $this->styleSequence($s);
75		} else {
76	48	throw new InvalidStyleException($s);
77		}
78		}
79
80		$sequences =
81	42	\array_filter(
82	42	\array_merge(...$sequences),
83		/**
84		* @param mixed $val
85		* @return bool
86		* @psalm-suppress MissingClosureParamType
87		*/
88		function ($val): bool {
89	42	return $val !== null;
90	42	}
91		);
92
93	42	return $sequences;
94		}
95
96		/**
97		* @param string $name
98		* @return string[]\|null[]
99		*/
100	15	protected function themeSequence($name): array
101		{
102	15	$sequences = [];
103	15	foreach ($this->themes[$name] as $style) {
104	15	$sequences[] = $this->styleSequence($style);
105		}
106	15	return $sequences;
107		}
108
109		/**
110		* @param string $style
111		* @return null\|string
112		*/
113	42	protected function styleSequence($style): ?string
114		{
115	42	if (\array_key_exists($style, static::STYLES)) {
116	30	return static::STYLES[$style];
117		}
118
119	12	if (!$this->are256ColorsSupported()) {
120	3	return null;
121		}
122
123		return
124	9	$this->process256ColorStyle($style);
125		}
126
127		/** {@inheritdoc} */
128	2	public function are256ColorsSupported(): bool
129		{
130	2	return $this->are256ColorsSupported;
131		}
132
133		/**
134		* @param string $style
135		* @return bool
136		*/
137	56	protected function isValidStyle($style): bool
138		{
139	56	return \array_key_exists($style, static::STYLES) \|\| \preg_match(self::COLOR256_REGEXP, $style);
140		}
141
142		/**
143		* @param string\|array $styles
144		* @return array
145		*/
146	59	protected function refineStyles($styles): array
147		{
148	59	if (\is_string($styles)) {
149	35	$styles = [$styles];
150		}
151	59	$this->assertStyles($styles);
152	56	return $styles;
153		}
154
155		/**
156		* @param mixed $styles
157		*/
158	59	protected function assertStyles($styles): void
159		{
160	59	if (!\is_array($styles)) {
161	3	throw new \InvalidArgumentException('Style must be string or array.');
162		}
163	56	}
164
165		/**
166		* @param string $text
167		* @param array $sequences
168		* @return string
169		*/
170	36	protected function applySequences(string $text, array $sequences): string
171		{
172		return
173	36	$this->escSequence(\implode(';', $sequences)) .
174	36	$text .
175	36	$this->escSequence((string)self::RESET_STYLE);
176		}
177
178		/**
179		* @param string $value
180		* @return string
181		*/
182	36	protected function escSequence(string $value): string
183		{
184	36	return "\033[{$value}m";
185		}
186
187		/** {@inheritdoc} */
188	6	public function setForceStyle(bool $forceStyle): void
189		{
190	6	$this->forceStyle = $forceStyle;
191	6	}
192
193		/** {@inheritdoc} */
194	1	public function getThemes(): array
195		{
196	1	return $this->themes;
197		}
198
199		/** {@inheritdoc} */
200	3	public function setThemes(array $themes): void
201		{
202	3	$this->themes = [];
203	3	foreach ($themes as $name => $styles) {
204	3	$this->addTheme($name, $styles);
205		}
206	3	}
207
208		/** {@inheritdoc} */
209	23	public function addTheme($name, $styles): void
210		{
211	23	$styles = $this->refineStyles($styles);
212
213	23	foreach ($styles as $style) {
214	23	if (!$this->isValidStyle($style)) {
215	23	throw new InvalidStyleException($style);
216		}
217		}
218
219	20	$this->themes[$name] = $styles;
220	20	}
221
222		/** {@inheritdoc} */
223	3	public function hasTheme($name): bool
224		{
225	3	return isset($this->themes[$name]);
226		}
227
228		/** {@inheritdoc} */
229	3	public function removeTheme($name): void
230		{
231	3	unset($this->themes[$name]);
232	3	}
233
234		/** {@inheritdoc} */
235	3	public function getPossibleStyles(): array
236		{
237	3	return \array_keys(static::STYLES);
238		}
239
240		/**
241		* @param string $style
242		* @return string
243		*/
244	9	protected function process256ColorStyle(string $style): string
245		{
246	9	\preg_match(self::COLOR256_REGEXP, $style, $matches);
247
248	9	$type = $matches[1] === 'bg_' ? self::BACKGROUND : self::FOREGROUND;
249	9	$value = $matches[2];
250
251	9	return "$type;5;$value";
252		}
253		}
254

alecrabbit / php-console-colour

Push — master ( c7da00...5ce46b )

ConsoleColor::getSequencesFrom() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like