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

Passed

Push — master ( 095b07...d08e35 )

by Alec

created 2019-08-28 14:47 UTC

Spinner::initJugglers() A

↳ Parent: Spinner

Complexity

Conditions	3
Paths	4

Size

Total Lines	13
Code Lines	8

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	9
CRAP Score	3

Importance

Changes	3
Bugs	0	Features	0

Metric	Value
eloc	8
c	3
b	0
f	0
dl	0
loc	13
ccs	9
cts	9
cp	1
rs	10
cc	3
nc	4
nop	0
crap	3

<?php declare(strict_types=1);

namespace AlecRabbit\Spinner\Core;

use AlecRabbit\Cli\Tools\Cursor;
use AlecRabbit\Spinner\Core\Adapters\EchoOutputAdapter;
use AlecRabbit\Spinner\Core\Contracts\Frames;
use AlecRabbit\Spinner\Core\Contracts\SpinnerInterface;
use AlecRabbit\Spinner\Core\Contracts\SpinnerOutputInterface;
use AlecRabbit\Spinner\Core\Contracts\StylesInterface;
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\typeOf;
use const AlecRabbit\ESC;

abstract class Spinner implements SpinnerInterface
{
    protected const EMPTY_STRING = Defaults::EMPTY_STRING;

    protected const INTERVAL = Defaults::DEFAULT_INTERVAL;
    protected const FRAMES = Frames::BASE;
    protected const STYLES = StylesInterface::STYLING_DISABLED;

    /** @var null|SpinnerOutputInterface */
    protected $output;
    /** @var Settings */
    protected $settings;
    /** @var bool */
    protected $inline = false;
    /** @var float */
    protected $interval;
    /** @var null|MessageJuggler */
    protected $messageJuggler;
    /** @var null|FrameJuggler */
    protected $frameJuggler;
    /** @var null|ProgressJuggler */
    protected $progressJuggler;
    /** @var string */
    protected $moveCursorBackSequence = '';
    /** @var string */
    protected $eraseBySpacesSequence = '';
    /** @var string */
    protected $spacer = Defaults::EMPTY_STRING;
    /** @var Style */
    protected $style;
    /** @var null[]|JugglerInterface[] */
    protected $jugglers = [];

    /**
     * Spinner constructor.
     *
     * @param null|string|Settings $messageOrSettings
     * @param null|false|SpinnerOutputInterface $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->initJugglers();
        try {
            $this->style = new Style($this->settings->getStyles(), $color);
        } catch (\Throwable $e) {
            throw new \InvalidArgumentException(
                '[' . static::class . '] ' . $e->getMessage(),
                (int)$e->getCode(),
                $e
            );
        }
        $this->jugglers = [
            &$this->frameJuggler,
            &$this->messageJuggler,
            &$this->progressJuggler,
        ];
    }

    /**
     * @param null|false|SpinnerOutputInterface $output
     * @return null|SpinnerOutputInterface
     */
    protected function refineOutput($output): ?SpinnerOutputInterface
    {
        $this->assertOutput($output);
        if (false === $output) {
            return null;
        }
        return $output ?? new EchoOutputAdapter();
    }

    /**
     * @param mixed $output
     */
    protected function assertOutput($output): void
    {
        if (null !== $output && false !== $output && !$output instanceof SpinnerOutputInterface) {
            $typeOrValue =
                true === $output ? 'true' : typeOf($output);
            throw new \InvalidArgumentException(
                'Incorrect parameter: ' .
                '[null|false|' . SpinnerOutputInterface::class . '] expected'
                . ' "' . $typeOrValue . '" given.'
            );
        }
    }

    /**
     * @param null|string|Settings $settings
     * @return Settings
     */
    protected function refineSettings($settings): Settings
    {
        $this->assertSettings($settings);
        if (\is_string($settings)) {
            return
                $this->defaultSettings()->setMessage($settings);
        }
        if ($settings instanceof Settings) {
            return $this->defaultSettings()->merge($settings);
        }
        return
            $this->defaultSettings();
    }

    /**
     * @param mixed $settings
     */
    protected function assertSettings($settings): void
    {
        if (null !== $settings && !\is_string($settings) && !$settings instanceof Settings) {
            throw new \InvalidArgumentException(
                'Instance of [' . Settings::class . '] or string expected ' . typeOf($settings) . ' given.'
            );
        }
    }

    /**
     * @return Settings
     */
    protected function defaultSettings(): Settings
    {
        return
            (new Settings())
                ->setInterval(static::INTERVAL)
                ->setFrames(static::FRAMES)
                ->setStyles(static::STYLES);
    }

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

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

    }


    /**
     * @param null|string $message
     * @param null|int $erasingLength
     */
    protected function setMessage(?string $message, ?int $erasingLength = null): void
    {
        if ($this->messageJuggler instanceof MessageJuggler) {
            if (null === $message) {
                $this->messageJuggler = null;
            } else {
                $this->messageJuggler->setMessage($message, $erasingLength);
            }
        } else {
            $this->messageJuggler =
                null === $message ? null : new MessageJuggler($message, $erasingLength);
        }
    }

    /** {@inheritDoc} */
    public function end(): string
    {
        if ($this->output instanceof SpinnerOutputInterface) {
            $this->erase();
            $this->output->write(Cursor::show());
            return self::EMPTY_STRING;
        }
        return $this->erase() . Cursor::show();
    }

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

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

    public function inline(bool $inline): SpinnerInterface
    {
        $this->inline = $inline;
        $this->spacer = $this->inline ? Defaults::ONE_SPACE_SYMBOL : Defaults::EMPTY_STRING;
        return $this;
    }

    public function interval(): float
    {
        return $this->interval;
    }

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

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

        return $this;
    }

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

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

    /** {@inheritDoc} */
    public function spin(): string
    {
        if ($this->output instanceof SpinnerOutputInterface) {
            $this->output->write($this->preparedStr());
            return self::EMPTY_STRING;
        }
        return
            $this->preparedStr();
    }

    protected function preparedStr(): string
    {
        // TODO optimize for performance
        $str = '';
        $erasingLength = 0;
        $erasingLengthDelta = 0;
        $eraseMessageTailBySpacesSequence = '';
        if ($this->frameJuggler instanceof FrameJuggler) {
            $str .= $this->style->spinner($this->frameJuggler->getFrame());
            $erasingLength += $this->frameJuggler->getFrameErasingLength();
        }
        if ($this->messageJuggler instanceof MessageJuggler) {
            $str .= $this->style->message($this->messageJuggler->getFrame());
            $erasingLength += $this->messageJuggler->getFrameErasingLength();
            $erasingLengthDelta = $this->messageJuggler->getErasingLengthDelta();
            if ($erasingLengthDelta > 0) {
                $erasingLength += $erasingLengthDelta;
            } else {
                $erasingLengthDelta = 0;
            }
        }
        if ($this->progressJuggler instanceof ProgressJuggler) {
            $str .= $this->style->percent($this->progressJuggler->getFrame());
            $erasingLength += $this->progressJuggler->getFrameErasingLength();
        }
        $erasingLength += $this->inline ? 1 : 0;
        $this->moveCursorBackSequence = ESC . "[{$erasingLength}D";
        $this->eraseBySpacesSequence = str_repeat(Defaults::ONE_SPACE_SYMBOL, $erasingLength);
        if ($erasingLengthDelta > 0) {
            $eraseMessageTailBySpacesSequence = str_repeat(Defaults::ONE_SPACE_SYMBOL, $erasingLengthDelta);
        }
        return $this->spacer . $str . $eraseMessageTailBySpacesSequence . $this->moveCursorBackSequence;
    }
}


1		<?php declare(strict_types=1);
2
3		namespace AlecRabbit\Spinner\Core;
4
5		use AlecRabbit\Cli\Tools\Cursor;
6		use AlecRabbit\Spinner\Core\Adapters\EchoOutputAdapter;
7		use AlecRabbit\Spinner\Core\Contracts\Frames;
8		use AlecRabbit\Spinner\Core\Contracts\SpinnerInterface;
9		use AlecRabbit\Spinner\Core\Contracts\SpinnerOutputInterface;
10		use AlecRabbit\Spinner\Core\Contracts\StylesInterface;
11		use AlecRabbit\Spinner\Core\Jugglers\Contracts\JugglerInterface;
12		use AlecRabbit\Spinner\Core\Jugglers\FrameJuggler;
13		use AlecRabbit\Spinner\Core\Jugglers\MessageJuggler;
14		use AlecRabbit\Spinner\Core\Jugglers\ProgressJuggler;
15		use AlecRabbit\Spinner\Settings\Contracts\Defaults;
16		use AlecRabbit\Spinner\Settings\Settings;
17		use function AlecRabbit\typeOf;
18		use const AlecRabbit\ESC;
19
20		abstract class Spinner implements SpinnerInterface
21		{
22		protected const EMPTY_STRING = Defaults::EMPTY_STRING;
23
24		protected const INTERVAL = Defaults::DEFAULT_INTERVAL;
25		protected const FRAMES = Frames::BASE;
26		protected const STYLES = StylesInterface::STYLING_DISABLED;
27
28		/** @var null\|SpinnerOutputInterface */
29		protected $output;
30		/** @var Settings */
31		protected $settings;
32		/** @var bool */
33		protected $inline = false;
34		/** @var float */
35		protected $interval;
36		/** @var null\|MessageJuggler */
37		protected $messageJuggler;
38		/** @var null\|FrameJuggler */
39		protected $frameJuggler;
40		/** @var null\|ProgressJuggler */
41		protected $progressJuggler;
42		/** @var string */
43		protected $moveCursorBackSequence = '';
44		/** @var string */
45		protected $eraseBySpacesSequence = '';
46		/** @var string */
47		protected $spacer = Defaults::EMPTY_STRING;
48		/** @var Style */
49		protected $style;
50		/** @var null[]\|JugglerInterface[] */
51		protected $jugglers = [];
52
53		/**
54		* Spinner constructor.
55		*
56		* @param null\|string\|Settings $messageOrSettings
57		* @param null\|false\|SpinnerOutputInterface $output
58		* @param null\|int $color
59		*/
60	29	public function __construct($messageOrSettings = null, $output = null, ?int $color = null)
61		{
62	29	$this->output = $this->refineOutput($output);
63	27	$this->settings = $this->refineSettings($messageOrSettings);
64	26	$this->interval = $this->settings->getInterval();
65	26	$this->initJugglers();
66		try {
67	26	$this->style = new Style($this->settings->getStyles(), $color);
68	1	} catch (\Throwable $e) {
69	1	throw new \InvalidArgumentException(
70	1	'[' . static::class . '] ' . $e->getMessage(),
71	1	(int)$e->getCode(),
72	1	$e
73		);
74		}
75	25	$this->jugglers = [
76	25	&$this->frameJuggler,
77	25	&$this->messageJuggler,
78	25	&$this->progressJuggler,
79		];
80	25	}
81
82		/**
83		* @param null\|false\|SpinnerOutputInterface $output
84		* @return null\|SpinnerOutputInterface
85		*/
86	29	protected function refineOutput($output): ?SpinnerOutputInterface
87		{
88	29	$this->assertOutput($output);
89	27	if (false === $output) {
90	22	return null;
91		}
92	5	return $output ?? new EchoOutputAdapter();
93		}
94
95		/**
96		* @param mixed $output
97		*/
98	29	protected function assertOutput($output): void
99		{
100	29	if (null !== $output && false !== $output && !$output instanceof SpinnerOutputInterface) {
101		$typeOrValue =
102	2	true === $output ? 'true' : typeOf($output);
103	2	throw new \InvalidArgumentException(
104		'Incorrect parameter: ' .
105		'[null\|false\|' . SpinnerOutputInterface::class . '] expected'
106	2	. ' "' . $typeOrValue . '" given.'
107		);
108		}
109	27	}
110
111		/**
112		* @param null\|string\|Settings $settings
113		* @return Settings
114		*/
115	27	protected function refineSettings($settings): Settings
116		{
117	27	$this->assertSettings($settings);
118	26	if (\is_string($settings)) {
119		return
120	18	$this->defaultSettings()->setMessage($settings);
121		}
122	8	if ($settings instanceof Settings) {
123	5	return $this->defaultSettings()->merge($settings);
124		}
125		return
126	3	$this->defaultSettings();
127		}
128
129		/**
130		* @param mixed $settings
131		*/
132	27	protected function assertSettings($settings): void
133		{
134	27	if (null !== $settings && !\is_string($settings) && !$settings instanceof Settings) {
135	1	throw new \InvalidArgumentException(
136	1	'Instance of [' . Settings::class . '] or string expected ' . typeOf($settings) . ' given.'
137		);
138		}
139	26	}
140
141		/**
142		* @return Settings
143		*/
144	26	protected function defaultSettings(): Settings
145		{
146		return
147	26	(new Settings())
148	26	->setInterval(static::INTERVAL)
149	26	->setFrames(static::FRAMES)
150	26	->setStyles(static::STYLES);
151		}
152
153	26	protected function initJugglers(): void
154		{
155	26	$frames = $this->settings->getFrames();
156	26	if (!empty($frames)) {
157	20	$this->frameJuggler =
158	20	new FrameJuggler(
159	20	$frames
160		);
161		}
162
163	26	$message = $this->settings->getMessage();
164	26	if (Defaults::EMPTY_STRING !== $message) {
165	21	$this->setMessage($message, $this->settings->getMessageErasingLen());
166		}
167
168	26	}
		0 ignored issues – show Coding Style introduced 2019-08-28 14:50 UTC by Report Bug Copy Issue Report Function closing brace must go on the next line following the body; found 1 blank lines before brace Loading history...
169
170		/**
171		* @param null\|string $message
172		* @param null\|int $erasingLength
173		*/
174	22	protected function setMessage(?string $message, ?int $erasingLength = null): void
175		{
176	22	if ($this->messageJuggler instanceof MessageJuggler) {
177	5	if (null === $message) {
178	1	$this->messageJuggler = null;
179		} else {
180	5	$this->messageJuggler->setMessage($message, $erasingLength);
181		}
182		} else {
183	22	$this->messageJuggler =
184	22	null === $message ? null : new MessageJuggler($message, $erasingLength);
185		}
186	22	}
187
188		/** {@inheritDoc} */
189	21	public function end(): string
190		{
191	21	if ($this->output instanceof SpinnerOutputInterface) {
192	3	$this->erase();
193	3	$this->output->write(Cursor::show());
194	3	return self::EMPTY_STRING;
195		}
196	18	return $this->erase() . Cursor::show();
197		}
198
199		/** {@inheritDoc} */
200	21	public function erase(): string
201		{
202	21	$str = $this->eraseBySpacesSequence . $this->moveCursorBackSequence;
203	21	if ($this->output instanceof SpinnerOutputInterface) {
204	3	$this->output->write($str);
205	3	return self::EMPTY_STRING;
206		}
207	18	return $str;
208		}
209
210		/** {@inheritDoc} */
211	3	public function getOutput(): ?SpinnerOutputInterface
212		{
213	3	return $this->output;
214		}
215
216	8	public function inline(bool $inline): SpinnerInterface
217		{
218	8	$this->inline = $inline;
219	8	$this->spacer = $this->inline ? Defaults::ONE_SPACE_SYMBOL : Defaults::EMPTY_STRING;
220	8	return $this;
221		}
222
223	5	public function interval(): float
224		{
225	5	return $this->interval;
226		}
227
228		/** {@inheritDoc} */
229	5	public function message(?string $message = null, ?int $erasingLength = null): self
230		{
231	5	$this->setMessage($message, $erasingLength);
232	5	return $this;
233		}
234
235	10	public function progress(?float $percent): self
236		{
237	10	$this->setProgress($percent);
238	10	dump($this->jugglers);
239
240	10	return $this;
241		}
242
243		/**
244		* @param null\|float $percent
245		*/
246	11	protected function setProgress(?float $percent = null): void
247		{
248	11	if ($this->progressJuggler instanceof ProgressJuggler) {
249	10	if (null === $percent) {
250	1	$this->progressJuggler = null;
251		} else {
252	10	$this->progressJuggler->setProgress($percent);
253		}
254		} else {
255	11	$this->progressJuggler =
256	11	null === $percent ? null : new ProgressJuggler($percent);
257		}
258	11	}
259
260		/** {@inheritDoc} */
261	24	public function begin(?float $percent = null): string
262		{
263	24	if (null === $percent) {
264	20	$this->progressJuggler = null;
265		} else {
266	5	$this->setProgress($percent);
267		}
268	24	if ($this->output instanceof SpinnerOutputInterface) {
269	3	$this->output->write(Cursor::hide());
270	3	$this->spin();
271	3	return self::EMPTY_STRING;
272		}
273	21	return Cursor::hide() . $this->spin();
274		}
275
276		/** {@inheritDoc} */
277	24	public function spin(): string
278		{
279	24	if ($this->output instanceof SpinnerOutputInterface) {
280	3	$this->output->write($this->preparedStr());
281	3	return self::EMPTY_STRING;
282		}
283		return
284	21	$this->preparedStr();
285		}
286
287	24	protected function preparedStr(): string
288		{
289		// TODO optimize for performance
290	24	$str = '';
291	24	$erasingLength = 0;
292	24	$erasingLengthDelta = 0;
293	24	$eraseMessageTailBySpacesSequence = '';
294	24	if ($this->frameJuggler instanceof FrameJuggler) {
295	18	$str .= $this->style->spinner($this->frameJuggler->getFrame());
296	18	$erasingLength += $this->frameJuggler->getFrameErasingLength();
297		}
298	24	if ($this->messageJuggler instanceof MessageJuggler) {
299	21	$str .= $this->style->message($this->messageJuggler->getFrame());
300	21	$erasingLength += $this->messageJuggler->getFrameErasingLength();
301	21	$erasingLengthDelta = $this->messageJuggler->getErasingLengthDelta();
302	21	if ($erasingLengthDelta > 0) {
303	5	$erasingLength += $erasingLengthDelta;
304		} else {
305	20	$erasingLengthDelta = 0;
306		}
307		}
308	24	if ($this->progressJuggler instanceof ProgressJuggler) {
309	11	$str .= $this->style->percent($this->progressJuggler->getFrame());
310	11	$erasingLength += $this->progressJuggler->getFrameErasingLength();
311		}
312	24	$erasingLength += $this->inline ? 1 : 0;
313	24	$this->moveCursorBackSequence = ESC . "[{$erasingLength}D";
314	24	$this->eraseBySpacesSequence = str_repeat(Defaults::ONE_SPACE_SYMBOL, $erasingLength);
315	24	if ($erasingLengthDelta > 0) {
316	5	$eraseMessageTailBySpacesSequence = str_repeat(Defaults::ONE_SPACE_SYMBOL, $erasingLengthDelta);
317		}
318	24	return $this->spacer . $str . $eraseMessageTailBySpacesSequence . $this->moveCursorBackSequence;
319		}
320		}
321

alecrabbit / php-console-spinner

Push — master ( 095b07...d08e35 )

Spinner::initJugglers() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like