Bmatovu\Ussd\Ussd

Complexity

Total Complexity

25

Size/Duplication

Total Lines	162
Duplicated Lines	0 %

Test Coverage

Coverage

94.87%

Importance

Changes	1
Bugs	0	Features	0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	doBreak()	0	13	3
A	doParse()	0	18	3
A	handle()	0	19	4
A	new()	0	3	1
A	__construct()	0	21	3
A	doRender()	0	20	3
A	make()	0	3	1
A	entry()	0	7	2
A	save()	0	7	2
A	doProcess()	0	18	3

<?php

namespace Bmatovu\Ussd;

use Bmatovu\Ussd\Contracts\AnswerableTag;
use Bmatovu\Ussd\Support\Util;
use Bmatovu\Ussd\Traits\Utilities;
use Illuminate\Container\Container;
use Illuminate\Contracts\Config\Repository as ConfigRepository;
use Illuminate\Support\Facades\App;

class Ussd
{
    use Utilities;

The trait Bmatovu\Ussd\Traits\Utilities requires some properties which are not provided by Bmatovu\Ussd\Ussd: $tagName, $attributes, $nodeValue

    protected \DOMXPath $xpath;
    protected string $sessionId;
    protected Store $store;
    protected bool $newSession = false;

    /**
     * @param \DOMXPath|string $menu
     */
    public function __construct($menu, string $sessionId)
    {
        $this->xpath = $menu instanceof \DOMXPath ? $menu : $this->fileToXpath($menu);

        $config = Container::getInstance()->make(ConfigRepository::class);
        $store = $config->get('ussd.cache.store', 'file');
        $ttl = $config->get('ussd.cache.ttl', 120);
        $this->store = new Store($store, $ttl, $sessionId);

        App::setLocale($this->store->get('locale', 'en'));

        if ($this->sessionExists($sessionId)) {
            return;
        }

        $this->newSession = true;
        $this->store->put('_session_id', $sessionId);
        $this->store->put('_answer', '');
        $this->store->put('_pre', '');
        $this->store->put('_exp', '/menu/*[1]');
        $this->store->put('_breakpoints', '[]');
    }

    /**
     * @param \DOMXPath|string $menu
     */
    public static function make($menu, string $sessionId): self
    {
        return new static($menu, $sessionId);
    }

    public static function new(...$args): self
    {
        return new static(...$args);
    }

    public function entry(string $expression): self
    {
        if ($this->newSession) {
            $this->store->put('_exp', $expression);
        }

        return $this;
    }

    public function save(array $options): self
    {
        foreach ($options as $key => $value) {
            $this->store->put($key, $value);
        }

        return $this;
    }

    public function handle(?string $userInput = ''): string
    {
        $answer = $this->getAnswer($userInput);

        if ($this->newSession) {
            $inquiry = $this->doParse();

            if (!$answer) {
                return $inquiry;
            }
        }

        $answers = explode('*', $answer);

        foreach ($answers as $answer) {
            $inquiry = $this->doParse($answer);
        }

        return $inquiry;

The variable $inquiry does not seem to be defined for all execution paths leading up to this point.

    }

    protected function doParse(?string $answer = ''): ?string
    {
        $this->doProcess($answer);

        $exp = $this->store->get('_exp');
        $node = $this->xpath->query($exp)->item(0);

        if (!$node) {
            $this->doBreak();
        }

        $inquiry = $this->doRender();

        if (!$inquiry) {
            return $this->doParse($answer);
        }

        return $inquiry;
    }

    protected function doProcess(?string $answer): void
    {
        $pre = $this->store->get('_pre');

        if (!$pre) {
            return;
        }

        $preNode = $this->xpath->query($pre)->item(0);

        $tagName = $this->resolveTagName($preNode);
        $tag = $this->instantiateTag($tagName, [$preNode, $this->store]);

        if (!$tag instanceof AnswerableTag) {
            return;
        }

        $tag->process($answer);
    }

    protected function doBreak(): void
    {
        $exp = $this->store->get('_exp');

        $breakpoints = (array) json_decode((string) $this->store->get('_breakpoints'), true);

        if (!$breakpoints || !isset($breakpoints[0][$exp])) {

The expression $breakpoints of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using empty($expr) instead to make it clear that you intend to check for an array without elements.

            throw new \Exception(Util::hydrate($this->store, trans('MissingTag')));
        }

        $breakpoint = array_shift($breakpoints);
        $this->store->put('_exp', $breakpoint[$exp]);
        $this->store->put('_breakpoints', json_encode($breakpoints));
    }

    protected function doRender(): ?string
    {
        $exp = $this->store->get('_exp');

        $node = $this->xpath->query($exp)->item(0);

        $tagName = $this->resolveTagName($node);
        $tag = $this->instantiateTag($tagName, [$node, $this->store]);
        $inquiry = $tag->handle();

        $exp = $this->store->get('_exp');
        $breakpoints = (array) json_decode((string) $this->store->get('_breakpoints'), true);

        if ($breakpoints && isset($breakpoints[0][$exp])) {

The expression $breakpoints of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            $breakpoint = array_shift($breakpoints);
            $this->store->put('_exp', $breakpoint[$exp]);
            $this->store->put('_breakpoints', json_encode($breakpoints));
        }

        return $inquiry;
    }
}