PhpJsonRpc\Server\Processor

Complexity

Total Complexity

17

Size/Duplication

Total Lines	126
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	12

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	handleCallUnit()	0	11	2
A	handleNotificationUnit()	0	11	2
A	handleErrorUnit()	0	4	1
A	__construct()	0	5	1
A	addHandler()	0	9	2
A	setMapper()	0	4	1
A	process()	0	17	4
A	getClassAndMethod()	0	10	4

<?php

namespace PhpJsonRpc\Server;

use PhpJsonRpc\Core\Call\CallUnit;
use PhpJsonRpc\Core\Call\CallError;
use PhpJsonRpc\Core\Call\CallNotification;
use PhpJsonRpc\Core\CallSpecifier;
use PhpJsonRpc\Core\Result\AbstractResult;
use PhpJsonRpc\Core\Result\ResultError;
use PhpJsonRpc\Core\Result\ResultNotification;
use PhpJsonRpc\Core\Result\ResultUnit;
use PhpJsonRpc\Core\ResultSpecifier;
use PhpJsonRpc\Error\JsonRpcException;
use PhpJsonRpc\Error\MethodNotFoundException;

class Processor
{
    /**
     * @var array
     */
    private $handlers = [];

    /**
     * @var MapperInterface
     */
    private $mapper;

    /**
     * @var Invoker
     */
    private $invoker;

    /**
     * Processor constructor.
     */
    public function __construct()
    {
        $this->mapper  = new Mapper();
        $this->invoker = new Invoker();
    }

    /**
     * @param mixed $object
     */
    public function addHandler($object)
    {
        if (!is_object($object)) {
            throw new \DomainException('Expected object');
        }

        $key = get_class($object);
        $this->handlers[$key] = $object;
    }

    /**
     * @param MapperInterface $mapper
     */
    public function setMapper(MapperInterface $mapper)
    {
        $this->mapper = $mapper;
    }

    /**
     * @param CallSpecifier $specifier
     * @return ResultSpecifier
     */
    public function process(CallSpecifier $specifier): ResultSpecifier
    {
        $resultUnits = [];
        $callUnits   = $specifier->getUnits();

        foreach ($callUnits as $unit) {
            if ($unit instanceof CallUnit) {
                $resultUnits[] = $this->handleCallUnit($unit);
            } elseif ($unit instanceof CallNotification) {
                $resultUnits[] = $this->handleNotificationUnit($unit);
            } else {
                $resultUnits[] = $this->handleErrorUnit($unit);
            }
        }

        return new ResultSpecifier($resultUnits, $specifier->isSingleCall());
    }

    /**
     * @param CallUnit $unit
     * @return AbstractResult
     */
    private function handleCallUnit(CallUnit $unit): AbstractResult
    {
        try {
            list($class, $method) = $this->getClassAndMethod($unit->getRawMethod());
            $result = $this->invoker->invoke($this->handlers[$class], $method, $unit->getRawParams());
        } catch (JsonRpcException $exception) {
            return new ResultError($unit->getRawId(), $exception);
        }

        return new ResultUnit($unit->getRawId(), $result);
    }

    /**
     * @param CallNotification $unit
     * @return AbstractResult
     */
    private function handleNotificationUnit(CallNotification $unit): AbstractResult
    {
        try {
            list($class, $method) = $this->getClassAndMethod($unit->getRawMethod());
            $this->invoker->invoke($this->handlers[$class], $method, $unit->getRawParams());
        } catch (JsonRpcException $exception) {
            return new ResultError(null, $exception);
        }

        return new ResultNotification();
    }

    /**
     * @param CallError $unit
     * @return AbstractResult
     */
    private function handleErrorUnit(CallError $unit): AbstractResult
    {
        return new ResultError(null, $unit->getBaseException());
    }

    /**
     * @param string $requestedMethod
     * @return array
     * @throws MethodNotFoundException
     */
    private function getClassAndMethod(string $requestedMethod)
    {
        list($class, $method) = $this->mapper->getClassAndMethod($requestedMethod);

        if ($class && array_key_exists($class, $this->handlers) && method_exists($this->handlers[$class], $method)) {
            return [$class, $method];
        }

        throw new MethodNotFoundException();
    }
}