Moka\Proxy\ProxyTrait

Complexity

Total Complexity

12

Size/Duplication

Total Lines	114
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

100%

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__moka_getMock()	0	4	1
A	__moka_setMock()	0	6	1
A	__moka_setMockingStrategy()	0	6	1
A	stub()	0	17	4
A	doCall()	0	10	2
A	doGet()	0	12	3

<?php
declare(strict_types=1);

namespace Moka\Proxy;

use Moka\Exception\InvalidArgumentException;
use Moka\Exception\MockNotCreatedException;
use Moka\Strategy\MockingStrategyInterface;
use function Moka\Stub\Helper\isMethodName;
use function Moka\Stub\Helper\isPropertyName;
use function Moka\Stub\Helper\stripNameAndValidate;

/**
 * Trait ProxyTrait
 * @package Moka\Proxy
 */
trait ProxyTrait
{
    /**
     * @var object
     */
    private $__moka_mock;

    /**
     * @var MockingStrategyInterface
     */
    private $__moka_mockingStrategy;

    /**
     * @var array
     */
    private $__moka_properties = [];

    /**
     * @var array
     */
    private $__moka_methods = [];

    /**
     * @return object
     */
    public function __moka_getMock()
    {
        return $this->__moka_mock;
    }

    /**
     * @param object $mock
     * @return ProxyInterface|ProxyTrait
     */
    public function __moka_setMock($mock): self
    {
        $this->__moka_mock = $mock;

        return $this;
    }

    /**
     * @param MockingStrategyInterface $mockingStrategy
     * @return ProxyInterface|ProxyTrait
     */
    public function __moka_setMockingStrategy(MockingStrategyInterface $mockingStrategy): self
    {
        $this->__moka_mockingStrategy = $mockingStrategy;

        return $this;
    }

    /**
     * @param array $namesWithValues
     * @return ProxyInterface
     *
     * @throws InvalidArgumentException
     * @throws MockNotCreatedException
     */
    public function stub(array $namesWithValues): ProxyInterface
    {
        foreach ($namesWithValues as $name => $value) {
            if (isPropertyName($name)) {
                $this->__moka_properties[] = stripNameAndValidate($name);
            }

            if (isMethodName($name)) {
                $this->__moka_methods[] = stripNameAndValidate($name);
            }
        }

        /** @var $this ProxyInterface */
        $this->__moka_mockingStrategy->decorate($this->__moka_mock, $namesWithValues);

        return $this;
    }

    /**
     * @param string $name
     * @param array $arguments
     * @return mixed
     * @throws InvalidArgumentException
     * @throws MockNotCreatedException
     */
    protected function doCall(string $name, array $arguments)
    {
        if (!$this->__moka_mockingStrategy instanceof MockingStrategyInterface) {
            return null;
        }

        $target = $this->__moka_mockingStrategy->get($this->__moka_mock);

        return $target->$name(...$arguments);
    }

    /**
     * @param string $name
     * @return mixed
     * @throws InvalidArgumentException
     * @throws MockNotCreatedException
     */
    protected function doGet(string $name)
    {
        if (!$this->__moka_mockingStrategy instanceof MockingStrategyInterface) {
            return null;
        }

        if (\in_array($name, $this->__moka_properties, $strict = false)) {
            return $this->__moka_mockingStrategy->get($this->__moka_mock)->$name;
        }

        return $this->__moka_mockingStrategy->call($this->__moka_mock, $name);
    }
}