Prozorov\Repositories\RepositoryFactory

Complexity

Total Complexity

17

Size/Duplication

Total Lines	189
Duplicated Lines	0 %

Test Coverage

Coverage

90.57%

Importance

Changes	2
Bugs	0	Features	0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	resolveCallable()	0	16	3
A	loadFixtures()	0	12	1
A	mock()	0	17	1
A	getFixtureResolver()	0	9	2
A	getSolid()	0	9	2
A	resetAll()	0	4	2
A	__construct()	0	9	3
A	getRepository()	0	9	2
A	reset()	0	3	1

<?php

declare(strict_types=1);

namespace Prozorov\Repositories;

use Prozorov\Repositories\Contracts\{FixtureResolverInterface, RepositoryInterface, ResolverInterface};
use Prozorov\Repositories\Exceptions\CouldNotResolve;
use Mockery;

class RepositoryFactory
{
    /**
     * @var array $bindings
     */
    protected $bindings = [];

    /**
     * @var array $resolved
     */
    protected $resolved = [];

    /**
     * @var ResolverInterface $resolver
     */
    protected $resolver;

    /**
     * @var string $fixtureResolverClass
     */
    protected $fixtureResolverClass;

    /**
     * @var string $fixtureResolver
     */
    protected $fixtureResolver;

    public function __construct(ResolverInterface $resolver, array $bindings, string $fixtureResolverClass = null)
    {
        $this->resolver = $resolver;
        $this->bindings = $bindings;

        if (! empty($fixtureResolverClass) && class_exists($fixtureResolverClass)) {
            $this->fixtureResolverClass = $fixtureResolverClass;
        } else {
            $this->fixtureResolverClass = ArrayFixtureResolver::class;
        }
    }

    /**
     * getRepository.
     *
     * @access	public
     * @param	string	$code
     * @return	RepositoryInterface
     */
    public function getRepository(string $code): RepositoryInterface
    {
        $solid = $this->getSolid($code);

        if (empty($this->resolved[$solid])) {
            $this->resolved[$solid] = $this->resolver->resolve($solid);
        }

        return $this->resolved[$solid];
    }

    /**
     * getResolvedInstance.
     *
     * @access	protected
     * @param	string	$code	
     * @return	string
     */
    protected function getSolid(string $code): string
    {
        $solid = $this->bindings[$code] ?? $code;

        if (is_callable($solid)) {
            return $this->resolveCallable($code, $solid);
        }

        return $solid;
    }

    /**
     * Resolves callable
     *
     * @access	protected
     * @param	string  	$code 	
     * @param	callable	$solid	
     * @return	string
     */
    protected function resolveCallable(string $code, callable $solid): string
    {
        if (empty($this->resolved[$code])) {
            $resolved = $solid();

            if (! ($resolved instanceof RepositoryInterface)) {
                $exception = new CouldNotResolve();
                $exception->setRepositoryCode($code);

                throw $exception;
            }

            $this->resolved[$code] = $solid();
        }

        return $code;
    }

    /**
     * Clears resolved instance
     *
     * @access	public
     * @param	string	$code
     * @return	void
     */
    public function reset(string $code): void
    {
        unset($this->resolved[$code]);
    }

    /**
     * Clears resolved instance
     *
     * @access	public
     * @return	void
     */
    public function resetAll(): void
    {
        foreach ($this->resolved as $repository) {
            unset($repository);
        }
    }

    /**
     * getFixtureResolver.
     *
     * @access	protected
     * @return	FixtureResolverInterface
     */
    protected function getFixtureResolver(): FixtureResolverInterface
    {
        if (empty($this->fixtureResolver)) {
            $this->fixtureResolver = new $this->fixtureResolverClass;

It seems like new $this->fixtureResolverClass() of type object is incompatible with the declared type string of property $fixtureResolver.

        }

        // Assert $this->fixtureResolver implements FixtureResolverInterface

        return $this->fixtureResolver;

The expression return $this->fixtureResolver could return the type string which is incompatible with the type-hinted return Prozorov\Repositories\Contracts\FixtureResolverInterface. Consider adding an additional type-check to rule them out.

    }

    /**
     * mock.
     *
     * @access	public
     * @param	string	$code	
     * @return	mixed
     */
    public function mock(string $code)
    {
        $solid = $this->getRepository($code);

        $className = get_class($solid);

        $this->reset($code);

        $solid = $this->getSolid($code);

        $mock = Mockery::mock($className)
            ->makePartial()
            ->shouldAllowMockingProtectedMethods();

        $this->resolved[$solid] = $mock;

        return $this->resolved[$solid];
    }

    /**
     * loadFixtures.
     *
     * @access	public
     * @param	string	$code
     * @param	mixed 	$fixtures
     * @return	void
     */
    public function loadFixtures(string $code, $fixtures): void
    {
        $solid = $this->getSolid($code);

        $this->mock($code);

        // Assert $code is a FixturableRepository

        $fixtures = $this->getFixtureResolver()->getFixtures($fixtures);

        $this->resolved[$solid]->shouldReceive('isFake')->andReturn(true);
        $this->resolved[$solid]->shouldReceive('fixtures')->andReturn($fixtures);
    }
}