EventGenerator::onEvent() - Code Metrics - remorhaz/php-json-data - Measure and Improve Code Quality continuously with Scrutinizer

EventGenerator::onEvent() A
last analyzed 2021-01-14 17:07 UTC

↳ Parent: EventGenerator

Complexity

Conditions	5
Paths	5

Size

Total Lines	23
Code Lines	18

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	5
eloc	18
nc	5
nop	1
dl	0
loc	23
rs	9.3554
c	0
b	0
f	0

<?php

declare(strict_types=1);

namespace Remorhaz\JSON\Data\Walker;

use Generator;
use Remorhaz\JSON\Data\Event\AfterArrayEvent;
use Remorhaz\JSON\Data\Event\AfterElementEvent;
use Remorhaz\JSON\Data\Event\AfterElementEventInterface;
use Remorhaz\JSON\Data\Event\AfterObjectEvent;
use Remorhaz\JSON\Data\Event\AfterPropertyEvent;
use Remorhaz\JSON\Data\Event\AfterPropertyEventInterface;
use Remorhaz\JSON\Data\Event\BeforeArrayEvent;
use Remorhaz\JSON\Data\Event\BeforeElementEvent;
use Remorhaz\JSON\Data\Event\BeforeElementEventInterface;
use Remorhaz\JSON\Data\Event\BeforeObjectEvent;
use Remorhaz\JSON\Data\Event\BeforePropertyEvent;
use Remorhaz\JSON\Data\Event\BeforePropertyEventInterface;
use Remorhaz\JSON\Data\Event\EventInterface;
use Remorhaz\JSON\Data\Event\ScalarEvent;
use Remorhaz\JSON\Data\Path\PathInterface;
use Remorhaz\JSON\Data\Value\ArrayValueInterface;
use Remorhaz\JSON\Data\Value\NodeValueInterface;
use Remorhaz\JSON\Data\Value\ObjectValueInterface;
use Remorhaz\JSON\Data\Value\ScalarValueInterface;

final class EventGenerator
{

    private $stack;

    private $path;

    public function __construct(NodeValueInterface $value, PathInterface $path)
    {
        $this->stack = [$value];
        $this->path = $path;
    }

    public function __invoke(): Generator
    {
        while (true) {
            if (empty($this->stack)) {
                return;
            }
            $entity = array_pop($this->stack);
            switch (true) {
                case $entity instanceof EventInterface:
                    yield from $this->onEvent($entity);
                    break;

                case $entity instanceof ScalarValueInterface:
                    yield from $this->onScalarValue($entity);
                    break;

                case $entity instanceof ArrayValueInterface:
                    yield from $this->onArrayValue($entity);
                    break;

                case $entity instanceof ObjectValueInterface:
                    yield from $this->onObjectValue($entity);
                    break;

                default:
                    throw new Exception\UnexpectedEntityException($entity);
            }
        }
    }

    private function onEvent(EventInterface $event): Generator
    {
        switch (true) {
            case $event instanceof BeforeElementEventInterface:
                $this->path = $this
                    ->path
                    ->copyWithElement($event->getIndex());
                break;

            case $event instanceof BeforePropertyEventInterface:
                $this->path = $this
                    ->path
                    ->copyWithProperty($event->getName());
                break;

            case $event instanceof AfterElementEventInterface:
            case $event instanceof AfterPropertyEventInterface:
                $this->path = $this
                    ->path
                    ->copyParent();
                break;
        }
        yield $event;
    }

    private function onScalarValue(ScalarValueInterface $value): Generator
    {
        yield new ScalarEvent($value->getData(), $this->path);
    }

    private function onArrayValue(ArrayValueInterface $value): Generator
    {
        $localStack = [];
        foreach ($value->createChildIterator() as $index => $child) {
            $elementPath = $this
                ->path
                ->copyWithElement($index);
                ->copyWithElement(/** @scrutinizer ignore-type */ $index);
            array_push(
                $localStack,
                new BeforeElementEvent($index, $elementPath),
                new BeforeElementEvent(/** @scrutinizer ignore-type */ $index, $elementPath),
                $child,
                new AfterElementEvent($index, $elementPath)
                new AfterElementEvent(/** @scrutinizer ignore-type */ $index, $elementPath)
            );
        }
        array_push(
            $this->stack,
            new AfterArrayEvent($this->path),
            ...array_reverse($localStack)
        );
        yield new BeforeArrayEvent($this->path);
    }

    private function onObjectValue(ObjectValueInterface $value): Generator
    {
        $localStack = [];
        foreach ($value->createChildIterator() as $name => $child) {
            $elementPath = $this
                ->path
                ->copyWithProperty($name);
                ->copyWithProperty(/** @scrutinizer ignore-type */ $name);
            array_push(
                $localStack,
                new BeforePropertyEvent($name, $elementPath),
                new BeforePropertyEvent(/** @scrutinizer ignore-type */ $name, $elementPath),
                $child,
                new AfterPropertyEvent($name, $elementPath)
                new AfterPropertyEvent(/** @scrutinizer ignore-type */ $name, $elementPath)
            );
        }
        array_push(
            $this->stack,
            new AfterObjectEvent($this->path),
            ...array_reverse($localStack)
        );
        yield new BeforeObjectEvent($this->path);
    }
}


remorhaz / php-json-data

EventGenerator::onEvent() A last analyzed 2021-01-14 17:07 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

EventGenerator::onEvent() A
last analyzed 2021-01-14 17:07 UTC