Spinner::prepareLastOutput() - Code Metrics - Inspection of "changelog" - alecrabbit/php-console-spinner - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 43b6bd...c3bc4f )

by Alec

created 2019-09-19 15:15 UTC

Spinner::prepareLastOutput() A

↳ Parent: Spinner

Complexity

Conditions	3
Paths	3

Size

Total Lines	17
Code Lines	10

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	11
CRAP Score	3

Importance

Changes

Metric	Value
eloc	10
c	0
b	0
f	0
dl	0
loc	17
ccs	11
cts	11
cp	1
rs	9.9332
cc	3
nc	3
nop	0
crap	3

<?php declare(strict_types=1);

namespace AlecRabbit\Spinner\Core;

use AlecRabbit\Cli\Tools\Core\Terminal;
use AlecRabbit\Cli\Tools\Cursor;
use AlecRabbit\Spinner\Core\Coloring\Colors;
use AlecRabbit\Spinner\Core\Contracts\OutputInterface;
use AlecRabbit\Spinner\Core\Contracts\SpinnerInterface;
use AlecRabbit\Spinner\Core\Jugglers\Contracts\JugglerInterface;
use AlecRabbit\Spinner\Core\Jugglers\FrameJuggler;
use AlecRabbit\Spinner\Core\Jugglers\MessageJuggler;
use AlecRabbit\Spinner\Core\Jugglers\ProgressJuggler;
use AlecRabbit\Spinner\Settings\Contracts\Defaults;
use AlecRabbit\Spinner\Settings\Settings;
use function AlecRabbit\Helpers\wcswidth;
use const AlecRabbit\ESC;
use const AlecRabbit\NO_COLOR_TERMINAL;

abstract class Spinner extends SpinnerCore
{
    /** @var Settings */
    protected $settings;
    /** @var bool */
    protected $inline = false;
    /** @var null|MessageJuggler */
    protected $messageJuggler;
    /** @var null|FrameJuggler */
    protected $frameJuggler;
    /** @var null|ProgressJuggler */
    protected $progressJuggler;
    /** @var string */
    protected $moveCursorBackSequence = self::EMPTY_STRING;
    /** @var string */
    protected $eraseBySpacesSequence = self::EMPTY_STRING;
    /** @var int */
    protected $previousErasingWidth = 0;
    /** @var Colors */
    protected $coloring;
    /** @var null[]|JugglerInterface[] */
    protected $jugglers = [];
    /** @var string */
    protected $lastOutput = self::EMPTY_STRING;
    /** @var string */
    protected $inlineSpacer = self::EMPTY_STRING;
    /** @var bool */
    protected $hideCursor;
    /** @var int */
    protected $inlineSpacerWidth;
    /** @var string */
    protected $spacerValue;

    /**
     * Spinner constructor.
     *
     * @param null|string|Settings $messageOrSettings
     * @param null|false|OutputInterface $output
     * @param null|int $color
     */
    public function __construct($messageOrSettings = null, $output = null, ?int $color = null)
    {
        $this->output = $this->refineOutput($output);
        $this->settings = $this->refineSettings($messageOrSettings);
        $this->interval = $this->settings->getInterval();
        $this->hideCursor = $this->settings->isHideCursor();
        $this->enabled = $this->settings->isEnabled();
        $this->spacerValue = $this->settings->getInlineSpacer();
        $this->updateInlineSpacerProperties();
        $this->coloring = new Colors($this->settings->getStyles(), $this->refineColor($color));
        $jugglerOrder = $this->settings->getJugglersOrder();
        $this->jugglers = [
            $jugglerOrder[0] => &$this->frameJuggler,
            $jugglerOrder[1] => &$this->messageJuggler,
            $jugglerOrder[2] => &$this->progressJuggler,
        ];
        ksort($this->jugglers);
        $this->initJugglers();
    }

    /**
     * @param null|int $color
     * @return int
     */
    protected function refineColor(?int $color): int
    {
        if (null === $color && $this->output instanceof OutputInterface) {
            $color = Terminal::colorSupport($this->output->getStream());
        }
        return $color ?? NO_COLOR_TERMINAL;
    }

    protected function initJugglers(): void
    {
        $frames = $this->settings->getFrames();
        if (!empty($frames)) {
            $this->frameJuggler =
                new FrameJuggler($this->settings, $this->coloring->getFrameStyles());
        }

        $message = $this->settings->getMessage();
        if (self::EMPTY_STRING !== $message) {
            $this->setMessage($message);
        }
    }

    /**
     * @param null|string $message
     */
    protected function setMessage(?string $message): void
    {
        $this->settings->setMessage($message);

        if ($this->messageJuggler instanceof MessageJuggler) {
            if (null === $message) {
                $this->messageJuggler = null;
            } else {
                $this->messageJuggler->setMessage($message);
            }
        } else {
            $this->messageJuggler =
                null === $message ?
                    null :
                    new MessageJuggler($this->settings, $this->coloring->getMessageStyles());
        }
    }

    /** {@inheritDoc} */
    public function end(?string $finalMessage = null): string
    {
        if (!$this->enabled) {
            return self::EMPTY_STRING;
        }
        $finalMessage = (string)$finalMessage;
        $showCursor = $this->hideCursor ? Cursor::show() : self::EMPTY_STRING;
        if ($this->output instanceof OutputInterface) {
            $this->erase();
            $this->output->write($showCursor . $this->inlineSpacer . $finalMessage);
            return self::EMPTY_STRING;
        }
        return $this->erase() . $showCursor . $this->inlineSpacer . $finalMessage;
    }

    /** {@inheritDoc} */
    public function erase(): string
    {
        if (!$this->enabled) {
            return self::EMPTY_STRING;
        }
        $str = $this->eraseBySpacesSequence . $this->moveCursorBackSequence;
        if ($this->output instanceof OutputInterface) {
            $this->output->write($str);
            return self::EMPTY_STRING;
        }
        return $str;
    }

    /** {@inheritDoc} */
    public function getOutput(): ?OutputInterface
    {
        return $this->output;
    }

    public function inline(bool $inline): SpinnerInterface
    {
        $this->inline = $inline;
        $this->updateInlineSpacerProperties();
        return $this;
    }

    /** {@inheritDoc} */
    public function message(?string $message): self
    {
        $this->setMessage($message);
        return $this;
    }

    public function progress(?float $percent): self
    {
        $this->setProgress($percent);
        return $this;
    }

    /**
     * @param null|float $percent
     */
    protected function setProgress(?float $percent = null): void
    {
        $this->settings->setInitialPercent($percent);
        if ($this->progressJuggler instanceof ProgressJuggler) {
            if (null === $percent) {
                $this->progressJuggler = null;
            } else {
                $this->progressJuggler->setProgress($percent);
            }
        } else {
            $this->progressJuggler =
                null === $percent ? null : new ProgressJuggler($this->settings, $this->coloring->getProgressStyles());
        }
    }

    /** {@inheritDoc} */
    public function begin(?float $percent = null): string
    {
        if (!$this->enabled) {
            return self::EMPTY_STRING;
        }
        if (null === $percent) {
            $this->progressJuggler = null;
        } else {
            $this->setProgress($percent);
        }
        $hideCursor = $this->hideCursor ? Cursor::hide() : self::EMPTY_STRING;
        if ($this->output instanceof OutputInterface) {
            $this->output->write($hideCursor);
            $this->spin();
            return self::EMPTY_STRING;
        }
        return $hideCursor . $this->spin();
    }

    /** {@inheritDoc} */
    public function spin(): string
    {
        if (!$this->enabled) {
            return self::EMPTY_STRING;
        }
        $this->lastOutput = $this->prepareLastOutput();
        return
            $this->last();
    }

    protected function prepareLastOutput(): string
    {
//        $start = hrtime(true);
        $str = '';
        $erasingWidth = 0;
        foreach ($this->jugglers as $juggler) {
            if ($juggler instanceof JugglerInterface) {
                $str .= $juggler->getStyledFrame();
                $erasingWidth += $juggler->getFrameErasingWidth();
            }
        }
        $erasingWidth += $this->inlineSpacerWidth;
        $eraseTailBySpacesSequence = $this->calcEraseSequence($erasingWidth);

        $str = $this->inlineSpacer . $str . $eraseTailBySpacesSequence . $this->moveCursorBackSequence;
//        dump(hrtime(true) - $start);
        return $str;
    }

    /** {@inheritDoc} */
    public function last(): string
    {
        if (!$this->enabled) {
            return self::EMPTY_STRING;
        }
        if ($this->output instanceof OutputInterface) {
            $this->output->write($this->lastOutput);
            return self::EMPTY_STRING;
        }
        return
            $this->lastOutput;
    }

    protected function updateInlineSpacerProperties(): void
    {
        $this->inlineSpacer = $this->inline ? $this->spacerValue : self::EMPTY_STRING;
        $this->inlineSpacerWidth = $this->inline ? wcswidth($this->inlineSpacer) : 0;
    }

    /**
     * @param int $erasingWidth
     * @return string
     */
    protected function calcEraseSequence(int $erasingWidth): string
    {
        $eraseTailBySpacesSequence = '';

        $erasingWidthDelta = $this->previousErasingWidth - $erasingWidth;
        $this->previousErasingWidth = $erasingWidth;

        if ($erasingWidthDelta > 0) {
            $erasingWidth += $erasingWidthDelta;
            $eraseTailBySpacesSequence = str_repeat(Defaults::ONE_SPACE_SYMBOL, $erasingWidthDelta);
        }
        $this->eraseBySpacesSequence = str_repeat(Defaults::ONE_SPACE_SYMBOL, $erasingWidth);
        $this->moveCursorBackSequence = ESC . "[{$erasingWidth}D";

        return $eraseTailBySpacesSequence;
    }
}


1		<?php declare(strict_types=1);
2
3		namespace AlecRabbit\Spinner\Core;
4
5		use AlecRabbit\Cli\Tools\Core\Terminal;
6		use AlecRabbit\Cli\Tools\Cursor;
7		use AlecRabbit\Spinner\Core\Coloring\Colors;
8		use AlecRabbit\Spinner\Core\Contracts\OutputInterface;
9		use AlecRabbit\Spinner\Core\Contracts\SpinnerInterface;
10		use AlecRabbit\Spinner\Core\Jugglers\Contracts\JugglerInterface;
11		use AlecRabbit\Spinner\Core\Jugglers\FrameJuggler;
12		use AlecRabbit\Spinner\Core\Jugglers\MessageJuggler;
13		use AlecRabbit\Spinner\Core\Jugglers\ProgressJuggler;
14		use AlecRabbit\Spinner\Settings\Contracts\Defaults;
15		use AlecRabbit\Spinner\Settings\Settings;
16		use function AlecRabbit\Helpers\wcswidth;
17		use const AlecRabbit\ESC;
18		use const AlecRabbit\NO_COLOR_TERMINAL;
19
20		abstract class Spinner extends SpinnerCore
21		{
22		/** @var Settings */
23		protected $settings;
24		/** @var bool */
25		protected $inline = false;
26		/** @var null\|MessageJuggler */
27		protected $messageJuggler;
28		/** @var null\|FrameJuggler */
29		protected $frameJuggler;
30		/** @var null\|ProgressJuggler */
31		protected $progressJuggler;
32		/** @var string */
33		protected $moveCursorBackSequence = self::EMPTY_STRING;
34		/** @var string */
35		protected $eraseBySpacesSequence = self::EMPTY_STRING;
36		/** @var int */
37		protected $previousErasingWidth = 0;
38		/** @var Colors */
39		protected $coloring;
40		/** @var null[]\|JugglerInterface[] */
41		protected $jugglers = [];
42		/** @var string */
43		protected $lastOutput = self::EMPTY_STRING;
44		/** @var string */
45		protected $inlineSpacer = self::EMPTY_STRING;
46		/** @var bool */
47		protected $hideCursor;
48		/** @var int */
49		protected $inlineSpacerWidth;
50		/** @var string */
51		protected $spacerValue;
52
53		/**
54		* Spinner constructor.
55		*
56		* @param null\|string\|Settings $messageOrSettings
57		* @param null\|false\|OutputInterface $output
58		* @param null\|int $color
59		*/
60	30	public function __construct($messageOrSettings = null, $output = null, ?int $color = null)
61		{
62	30	$this->output = $this->refineOutput($output);
63	28	$this->settings = $this->refineSettings($messageOrSettings);
64	27	$this->interval = $this->settings->getInterval();
65	27	$this->hideCursor = $this->settings->isHideCursor();
66	27	$this->enabled = $this->settings->isEnabled();
67	27	$this->spacerValue = $this->settings->getInlineSpacer();
68	27	$this->updateInlineSpacerProperties();
69	27	$this->coloring = new Colors($this->settings->getStyles(), $this->refineColor($color));
70	27	$jugglerOrder = $this->settings->getJugglersOrder();
71	27	$this->jugglers = [
72	27	$jugglerOrder[0] => &$this->frameJuggler,
73	27	$jugglerOrder[1] => &$this->messageJuggler,
74	27	$jugglerOrder[2] => &$this->progressJuggler,
75		];
76	27	ksort($this->jugglers);
77	27	$this->initJugglers();
78	27	}
79
80		/**
81		* @param null\|int $color
82		* @return int
83		*/
84	27	protected function refineColor(?int $color): int
85		{
86	27	if (null === $color && $this->output instanceof OutputInterface) {
87	1	$color = Terminal::colorSupport($this->output->getStream());
88		}
89	27	return $color ?? NO_COLOR_TERMINAL;
90		}
91
92	27	protected function initJugglers(): void
93		{
94	27	$frames = $this->settings->getFrames();
95	27	if (!empty($frames)) {
96	21	$this->frameJuggler =
97	21	new FrameJuggler($this->settings, $this->coloring->getFrameStyles());
98		}
99
100	27	$message = $this->settings->getMessage();
101	27	if (self::EMPTY_STRING !== $message) {
102	23	$this->setMessage($message);
103		}
104	27	}
105
106		/**
107		* @param null\|string $message
108		*/
109	24	protected function setMessage(?string $message): void
110		{
111	24	$this->settings->setMessage($message);
112
113	24	if ($this->messageJuggler instanceof MessageJuggler) {
114	6	if (null === $message) {
115	3	$this->messageJuggler = null;
116		} else {
117	6	$this->messageJuggler->setMessage($message);
118		}
119		} else {
120	24	$this->messageJuggler =
121	24	null === $message ?
122	1	null :
123	24	new MessageJuggler($this->settings, $this->coloring->getMessageStyles());
124		}
125	24	}
126
127		/** {@inheritDoc} */
128	23	public function end(?string $finalMessage = null): string
129		{
130	23	if (!$this->enabled) {
131	1	return self::EMPTY_STRING;
132		}
133	23	$finalMessage = (string)$finalMessage;
134	23	$showCursor = $this->hideCursor ? Cursor::show() : self::EMPTY_STRING;
135	23	if ($this->output instanceof OutputInterface) {
136	3	$this->erase();
137	3	$this->output->write($showCursor . $this->inlineSpacer . $finalMessage);
138	3	return self::EMPTY_STRING;
139		}
140	20	return $this->erase() . $showCursor . $this->inlineSpacer . $finalMessage;
141		}
142
143		/** {@inheritDoc} */
144	23	public function erase(): string
145		{
146	23	if (!$this->enabled) {
147	1	return self::EMPTY_STRING;
148		}
149	23	$str = $this->eraseBySpacesSequence . $this->moveCursorBackSequence;
150	23	if ($this->output instanceof OutputInterface) {
151	3	$this->output->write($str);
152	3	return self::EMPTY_STRING;
153		}
154	20	return $str;
155		}
156
157		/** {@inheritDoc} */
158	5	public function getOutput(): ?OutputInterface
159		{
160	5	return $this->output;
161		}
162
163	8	public function inline(bool $inline): SpinnerInterface
164		{
165	8	$this->inline = $inline;
166	8	$this->updateInlineSpacerProperties();
167	8	return $this;
168		}
169
170		/** {@inheritDoc} */
171	6	public function message(?string $message): self
172		{
173	6	$this->setMessage($message);
174	6	return $this;
175		}
176
177	11	public function progress(?float $percent): self
178		{
179	11	$this->setProgress($percent);
180	11	return $this;
181		}
182
183		/**
184		* @param null\|float $percent
185		*/
186	12	protected function setProgress(?float $percent = null): void
187		{
188	12	$this->settings->setInitialPercent($percent);
189	12	if ($this->progressJuggler instanceof ProgressJuggler) {
190	11	if (null === $percent) {
191	2	$this->progressJuggler = null;
192		} else {
193	11	$this->progressJuggler->setProgress($percent);
194		}
195		} else {
196	12	$this->progressJuggler =
197	12	null === $percent ? null : new ProgressJuggler($this->settings, $this->coloring->getProgressStyles());
198		}
199	12	}
200
201		/** {@inheritDoc} */
202	26	public function begin(?float $percent = null): string
203		{
204	26	if (!$this->enabled) {
205	1	return self::EMPTY_STRING;
206		}
207	26	if (null === $percent) {
208	22	$this->progressJuggler = null;
209		} else {
210	5	$this->setProgress($percent);
211		}
212	26	$hideCursor = $this->hideCursor ? Cursor::hide() : self::EMPTY_STRING;
213	26	if ($this->output instanceof OutputInterface) {
214	3	$this->output->write($hideCursor);
215	3	$this->spin();
216	3	return self::EMPTY_STRING;
217		}
218	23	return $hideCursor . $this->spin();
219		}
220
221		/** {@inheritDoc} */
222	26	public function spin(): string
223		{
224	26	if (!$this->enabled) {
225	1	return self::EMPTY_STRING;
226		}
227	26	$this->lastOutput = $this->prepareLastOutput();
228		return
229	26	$this->last();
230		}
231
232	26	protected function prepareLastOutput(): string
233		{
234		// $start = hrtime(true);
235	26	$str = '';
236	26	$erasingWidth = 0;
237	26	foreach ($this->jugglers as $juggler) {
238	26	if ($juggler instanceof JugglerInterface) {
239	25	$str .= $juggler->getStyledFrame();
240	25	$erasingWidth += $juggler->getFrameErasingWidth();
241		}
242		}
243	26	$erasingWidth += $this->inlineSpacerWidth;
244	26	$eraseTailBySpacesSequence = $this->calcEraseSequence($erasingWidth);
245
246	26	$str = $this->inlineSpacer . $str . $eraseTailBySpacesSequence . $this->moveCursorBackSequence;
247		// dump(hrtime(true) - $start);
248	26	return $str;
249		}
250
251		/** {@inheritDoc} */
252	26	public function last(): string
253		{
254	26	if (!$this->enabled) {
255	1	return self::EMPTY_STRING;
256		}
257	26	if ($this->output instanceof OutputInterface) {
258	3	$this->output->write($this->lastOutput);
259	3	return self::EMPTY_STRING;
260		}
261		return
262	23	$this->lastOutput;
263		}
264
265	27	protected function updateInlineSpacerProperties(): void
266		{
267	27	$this->inlineSpacer = $this->inline ? $this->spacerValue : self::EMPTY_STRING;
268	27	$this->inlineSpacerWidth = $this->inline ? wcswidth($this->inlineSpacer) : 0;
269	27	}
270
271		/**
272		* @param int $erasingWidth
273		* @return string
274		*/
275	26	protected function calcEraseSequence(int $erasingWidth): string
276		{
277	26	$eraseTailBySpacesSequence = '';
278
279	26	$erasingWidthDelta = $this->previousErasingWidth - $erasingWidth;
280	26	$this->previousErasingWidth = $erasingWidth;
281
282	26	if ($erasingWidthDelta > 0) {
283	7	$erasingWidth += $erasingWidthDelta;
284	7	$eraseTailBySpacesSequence = str_repeat(Defaults::ONE_SPACE_SYMBOL, $erasingWidthDelta);
285		}
286	26	$this->eraseBySpacesSequence = str_repeat(Defaults::ONE_SPACE_SYMBOL, $erasingWidth);
287	26	$this->moveCursorBackSequence = ESC . "[{$erasingWidth}D";
288
289	26	return $eraseTailBySpacesSequence;
290		}
291		}
292

alecrabbit / php-console-spinner

Push — master ( 43b6bd...c3bc4f )

Spinner::prepareLastOutput() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like