ChainResolver::resolve() - Code Metrics - artem-prozorov/repos - Measure and Improve Code Quality continuously with Scrutinizer

ChainResolver::resolve() A
last analyzed 2020-07-27 19:31 UTC

↳ Parent: ChainResolver

Complexity

Conditions	3
Paths	3

Size

Total Lines	16
Code Lines	9

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	9
CRAP Score	3

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	3
eloc	9
nc	3
nop	1
dl	0
loc	16
ccs	9
cts	9
cp	1
crap	3
rs	9.9666
c	1
b	0
f	0

<?php

declare(strict_types=1);

namespace Prozorov\Repositories\Resolvers;

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

class ChainResolver implements ResolverInterface
{
    /**
     * @var array $chain
     */
    protected $chain;

    /**
     * @var array $resolvers
     */
    protected $resolvers;

    public function __construct(array $chain)
    {
        $this->chain = $chain;
    }

    /**
     * @inheritDoc
     */
    public function resolve(string $className): RepositoryInterface
    {
        foreach ($this->chain as $resolverName) {
            $resolver = $this->getResolver($resolverName);

            try {
                return $resolver->resolve($className);
            } catch (CouldNotResolve $exception) {
                continue;
            }
        }

        $exception = new CouldNotResolve();
        $exception->setRepositoryCode($className);

        throw $exception;
    }

    /**
     * Create resolver if needed and return it
     *
     * @access	protected
     * @param	string|ResolverInterface	$code	
     * @return	ResolverInterface
     */
    protected function getResolver($resolver): ResolverInterface
    {
        $resolverClass = is_object($resolver) ? get_class($resolver) : $resolver;

        if (empty($this->resolvers[$resolverClass])) {
            if (is_object($resolver)) {
                $this->resolvers[$resolverClass] = $resolver;
            } elseif (is_string($resolver) && class_exists($resolver)) {
                $this->resolvers[$resolverClass] = new $resolver;
            } else {
                throw new \InvalidArgumentException('Invalid resolver provided');
            }

        }
        
        return $this->resolvers[$resolverClass];
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace Prozorov\Repositories\Resolvers;
6
7		use Prozorov\Repositories\Contracts\{RepositoryInterface, ResolverInterface};
8		use Prozorov\Repositories\Exceptions\CouldNotResolve;
9
10		class ChainResolver implements ResolverInterface
11		{
12		/**
13		* @var array $chain
14		*/
15		protected $chain;
16
17		/**
18		* @var array $resolvers
19		*/
20		protected $resolvers;
21
22	5	public function __construct(array $chain)
23		{
24	5	$this->chain = $chain;
25	5	}
26
27		/**
28		* @inheritDoc
29		*/
30	5	public function resolve(string $className): RepositoryInterface
31		{
32	5	foreach ($this->chain as $resolverName) {
33	5	$resolver = $this->getResolver($resolverName);
34
35		try {
36	4	return $resolver->resolve($className);
37	3	} catch (CouldNotResolve $exception) {
38	3	continue;
39		}
40		}
41
42	2	$exception = new CouldNotResolve();
43	2	$exception->setRepositoryCode($className);
44
45	2	throw $exception;
46		}
47
48		/**
49		* Create resolver if needed and return it
50		*
51		* @access protected
52		* @param string\|ResolverInterface $code
53		* @return ResolverInterface
54		*/
55	5	protected function getResolver($resolver): ResolverInterface
56		{
57	5	$resolverClass = is_object($resolver) ? get_class($resolver) : $resolver;
58
59	5	if (empty($this->resolvers[$resolverClass])) {
60	5	if (is_object($resolver)) {
61	3	$this->resolvers[$resolverClass] = $resolver;
62	2	} elseif (is_string($resolver) && class_exists($resolver)) {
63	1	$this->resolvers[$resolverClass] = new $resolver;
64		} else {
65	1	throw new \InvalidArgumentException('Invalid resolver provided');
66		}
67
68		}
69
70	4	return $this->resolvers[$resolverClass];
71		}
72		}
73

artem-prozorov / repos

ChainResolver::resolve() A last analyzed 2020-07-27 19:31 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

ChainResolver::resolve() A
last analyzed 2020-07-27 19:31 UTC