Instantiator::reflect() - Code Metrics - franzose/kontrolio - Measure and Improve Code Quality continuously with Scrutinizer

Instantiator::reflect() A
last analyzed 2025-04-19 06:52 UTC

↳ Parent: Instantiator

Complexity

Conditions	3
Paths	3

Size

Total Lines	13
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	3
eloc	6
c	1
b	0
f	0
nc	3
nop	1
dl	0
loc	13
rs	10

<?php

namespace Kontrolio\Rules;

use ReflectionClass;
use ReflectionException;
use UnexpectedValueException;

final class Instantiator
{
    /**
     * Returns new instance of a rule by the given class name.
     *
     * @param string $class
     *
     * @return object|RuleInterface
     * @throws UnexpectedValueException
     * @throws ReflectionException
     */
    public function make($class)
    {
        return $this->reflect($class)->newInstanceWithoutConstructor();
    }

    /**
     * Returns new instance of a rule by the given class name and arguments.
     *
     * @param string $class
     * @param array $arguments
     *
     * @return object|RuleInterface
     * @throws UnexpectedValueException
     * @throws ReflectionException
     */
    public function makeWithArgs($class, array $arguments = [])
    {
        return $this->reflect($class)->newInstanceArgs($arguments);
    }

    /**
     * Creates reflection object for the given class name.
     *
     * @param string $class
     *
     * @return ReflectionClass
     * @throws ReflectionException
     */
    private function reflect($class)
    {
        $obj = (new ReflectionClass($class));

        if (!$obj->isInstantiable()) {
            throw new UnexpectedValueException('Rule class must be instantiable.');
        }

        if (!$obj->implementsInterface(RuleInterface::class)) {
            throw new UnexpectedValueException(sprintf('Rule must implement %s.', RuleInterface::class));
        }

        return $obj;
    }
}


1			<?php
2
3			namespace Kontrolio\Rules;
4
5			use ReflectionClass;
6			use ReflectionException;
7			use UnexpectedValueException;
8
9			final class Instantiator
10			{
11			/**
12			* Returns new instance of a rule by the given class name.
13			*
14			* @param string $class
15			*
16			* @return object\|RuleInterface
17			* @throws UnexpectedValueException
18			* @throws ReflectionException
19			*/
20			public function make($class)
21			{
22			return $this->reflect($class)->newInstanceWithoutConstructor();
23			}
24
25			/**
26			* Returns new instance of a rule by the given class name and arguments.
27			*
28			* @param string $class
29			* @param array $arguments
30			*
31			* @return object\|RuleInterface
32			* @throws UnexpectedValueException
33			* @throws ReflectionException
34			*/
35			public function makeWithArgs($class, array $arguments = [])
36			{
37			return $this->reflect($class)->newInstanceArgs($arguments);
38			}
39
40			/**
41			* Creates reflection object for the given class name.
42			*
43			* @param string $class
44			*
45			* @return ReflectionClass
46			* @throws ReflectionException
47			*/
48			private function reflect($class)
49			{
50			$obj = (new ReflectionClass($class));
51
52			if (!$obj->isInstantiable()) {
53			throw new UnexpectedValueException('Rule class must be instantiable.');
54			}
55
56			if (!$obj->implementsInterface(RuleInterface::class)) {
57			throw new UnexpectedValueException(sprintf('Rule must implement %s.', RuleInterface::class));
58			}
59
60			return $obj;
61			}
62			}
63

franzose / kontrolio

Instantiator::reflect() A last analyzed 2025-04-19 06:52 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

Instantiator::reflect() A
last analyzed 2025-04-19 06:52 UTC