KEINOS\MSTDN_TOOLS\Parser\ParserProtectedMethods

Complexity

Total Complexity

24

Size/Duplication

Total Lines	127
Duplicated Lines	0 %

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	setFlagUpByteLength()	0	3	1
A	isFlagUpEventUpdate()	0	3	2
A	setFlagUpEventUpdate()	0	3	1
A	bufferPayloadUpdate()	0	28	6
A	setFlagUpEventDelete()	0	3	1
A	clearBuffer()	0	3	1
A	isFlagUpEventDelete()	0	3	2
A	resetFlags()	0	5	1
A	isFlagUpAsEvent()	0	23	4
A	isSkippable()	0	12	4
A	__construct()	0	4	1

<?php

declare(strict_types=1);

namespace KEINOS\MSTDN_TOOLS\Parser;

class ParserProtectedMethods extends ParserStaticMethods
{
    /** @var bool */
    protected $flagByteLen;
    /** @var bool */
    protected $flagEventDelete;
    /** @var bool */
    protected $flagEventUpdate;
    /** @var string */
    protected $buffer;

    public function __construct()
    {
        $this->resetFlags();
        $this->clearBuffer();
    }

    /**
     * Buffers chunked payloads until accomplishes the data.
     *
     * @param  string $line
     * @return bool|array<string,mixed>
     */
    protected function bufferPayloadUpdate(string $line)
    {
        if (self::isDataBeginPayload($line)) {
            $this->buffer = self::trimEOL($line);
        } else {
            $this->buffer .= self::trimEOL($line);
        }

        if ($this->isDataEndPayload($line)) {
            $json = self::extractDataFromString($this->buffer);

            if ((false === $json) or !(is_string($json))) {
                return false;
            }

            $assoc_as_array = true; // JSON_OBJECT_AS_ARRAY
            $array = json_decode($json, $assoc_as_array);
            if (null === $array) {
                return false;
            }

            $this->resetFlags();
            $this->clearBuffer();

            return $array;
        }

        return false;
    }

    protected function clearBuffer(): void
    {
        $this->buffer = '';
    }

    protected function isSkippable(string $line): bool
    {
        if (self::isBlank($line) || self::isThump($line)) {
            return true;
        }

        if (self::isByteLenOfPayload($line)) {
            $this->setFlagUpByteLength(true);
            return true;
        }

        return $this->isFlagUpAsEvent($line);
    }

    protected function isFlagUpAsEvent(string $line): bool
    {
        if (! self::isEvent($line)) {
            return false;
        }

        // Reset flags when new event begin
        $this->setFlagUpEventUpdate(false);
        $this->setFlagUpEventDelete(false);
        $this->clearBuffer();

        if (self::isEventDelete($line)) {
            $this->setFlagUpEventDelete(true);
            return true;
        }

        if (self::isEventUpdate($line)) {
            $this->setFlagUpEventUpdate(true);
            return true;
        }

        // Unsupported flag
        return false;
    }

    protected function isFlagUpEventDelete(): bool
    {
        return ($this->flagByteLen && $this->flagEventDelete);
    }

    protected function isFlagUpEventUpdate(): bool
    {
        return ($this->flagByteLen && $this->flagEventUpdate);
    }

    protected function resetFlags(): void
    {
        $this->setFlagUpByteLength(false);
        $this->setFlagUpEventDelete(false);
        $this->setFlagUpEventUpdate(false);
    }

    protected function setFlagUpByteLength(bool $flag): void
    {
        $this->flagByteLen = $flag;
    }

    protected function setFlagUpEventUpdate(bool $flag): void
    {
        $this->flagEventUpdate = $flag;
    }

    protected function setFlagUpEventDelete(bool $flag): void
    {
        $this->flagEventDelete = $flag;
    }
}