Cypress\PatchManager\PatchManager

Complexity

Total Complexity

15

Size/Duplication

Total Lines	108
Duplicated Lines	0 %

Test Coverage

Coverage

91.67%

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	setEventDispatcherInterface()	0	3	1
A	handleSubject()	0	10	3
A	handleMany()	0	5	3
A	handle()	0	4	1
A	getMatchedOperations()	0	8	3
A	dispatchEvents()	0	9	2
A	doHandle()	0	7	1

<?php

declare(strict_types=1);

namespace Cypress\PatchManager;

use Cypress\PatchManager\Event\PatchManagerEvent;
use Cypress\PatchManager\Event\PatchManagerEvents;
use Cypress\PatchManager\Exception\HandlerNotFoundException;
use PhpCollection\Sequence;
use Symfony\Component\EventDispatcher\EventDispatcherInterface;

/**
 * The main entry point for the PatchManager bundle
 */
class PatchManager
{
    private OperationMatcher $operationMatcher;

Private member variable "operationMatcher" must contain a leading underscore

    private EventDispatcherInterface $eventDispatcherInterface;

Private member variable "eventDispatcherInterface" must contain a leading underscore

    private bool $strictMode;

Private member variable "strictMode" must contain a leading underscore

    /**
     * @param OperationMatcher $operationMatcher
     * @param bool $strictMode if true throws an error if no handler is found
     */
    public function __construct(OperationMatcher $operationMatcher, bool $strictMode = false)
    {
        $this->operationMatcher = $operationMatcher;
        $this->strictMode = $strictMode;
    }

    public function setEventDispatcherInterface(EventDispatcherInterface $eventDispatcherInterface): void
    {
        $this->eventDispatcherInterface = $eventDispatcherInterface;
    }

    /**
     * @param array<Patchable>|Patchable|\Traversable $subject a Patchable instance or a collection of instances
     * @throws Exception\InvalidJsonRequestContent
     * @throws Exception\MissingOperationNameRequest
     * @throws Exception\MissingOperationRequest
     * @throws HandlerNotFoundException
     */
    public function handle($subject): void
    {
        $matchedOperations = $this->getMatchedOperations($subject);
        $this->handleSubject($subject, $matchedOperations);
    }

    protected function doHandle(MatchedPatchOperation $matchedPatchOperation, Patchable $subject): void
    {
        $event = new PatchManagerEvent($matchedPatchOperation, $subject);
        $this->dispatchEvents($event, $matchedPatchOperation->getOpName(), PatchManagerEvents::PATCH_MANAGER_PRE);

        $matchedPatchOperation->process($subject);
        $this->dispatchEvents($event, $matchedPatchOperation->getOpName(), PatchManagerEvents::PATCH_MANAGER_POST);
    }

    /**
     * dispatch events if the eventDispatcher is present
     */
    protected function dispatchEvents(PatchManagerEvent $event, string $opName, string $type): void
    {
        if (!isset($this->eventDispatcherInterface)) {
            return;
        }
        $this->eventDispatcherInterface->dispatch($event, $type);
        $this->eventDispatcherInterface->dispatch(
            $event,
            sprintf('%s.%s', $type, $opName)
        );
    }

    /**
     * @param array|Patchable|\Traversable $subject a Patchable instance or a collection of instances
     * @throws Exception\InvalidJsonRequestContent
     * @throws Exception\MissingOperationNameRequest
     * @throws Exception\MissingOperationRequest
     * @throws HandlerNotFoundException
     * @return Sequence
     */
    private function getMatchedOperations($subject): Sequence
    {
        $matchedOperations = $this->operationMatcher->getMatchedOperations($subject);
        if ($this->strictMode && $matchedOperations->isEmpty()) {
            throw new HandlerNotFoundException($this->operationMatcher->getUnmatchedOperations($subject));
        }

        return $matchedOperations;
    }

    /**
     * @param array<Patchable>|Patchable|\Traversable<Patchable> $subject a Patchable instance or a collection of instances
     * @throws Exception\MissingOperationNameRequest
     * @throws Exception\MissingOperationRequest
     * @throws Exception\InvalidJsonRequestContent
     */
    private function handleSubject($subject, Sequence $matchedOperations): void
    {
        if (is_iterable($subject)) {
            $this->handleMany($subject);

It seems like $subject can also be of type Cypress\PatchManager\Patchable; however, parameter $subjects of Cypress\PatchManager\PatchManager::handleMany() does only seem to accept Cypress\PatchManager\Patchable[]&Traversable, maybe add an additional type check?

            return;
        }

        foreach ($matchedOperations as $matchedPatchOperation) {
            $this->doHandle($matchedPatchOperation, $subject);
        }
    }

    /**
     * @param array<Patchable>|\Traversable<Patchable> $subjects
     * @throws Exception\InvalidJsonRequestContent
     * @throws Exception\MissingOperationNameRequest
     * @throws Exception\MissingOperationRequest
     */
    private function handleMany($subjects): void
    {
        foreach ($subjects as $subject) {
            foreach ($this->operationMatcher->getMatchedOperations($subject) as $matchedPatchOperation) {
                $this->doHandle($matchedPatchOperation, $subject);
            }
        }
    }
}