HasInterfaces::getInterfaces() - Code Metrics - Inspection of "Add inheritance support" - railt/reflection - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Push — master ( 3b7232...dbe410 )

by Kirill

created 2018-07-20 01:14 UTC

HasInterfaces::getInterfaces() A

↳ Parent: HasInterfaces

Complexity

Conditions	2
Paths	2

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	3
CRAP Score	2.0625

Importance

Changes

Metric	Value
dl	0
loc	6
ccs	3
cts	4
cp	0.75
rs	10
c	0
b	0
f	0
cc	2
nc	2
nop	0
crap	2.0625

<?php
/**
 * This file is part of Railt package.
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
declare(strict_types=1);

namespace Railt\Reflection\Definition\Behaviour;

use Railt\Reflection\Contracts\Definition\Behaviour\ProvidesInterfaces;
use Railt\Reflection\Contracts\Definition\InterfaceDefinition;
use Railt\Reflection\Contracts\Definition\TypeDefinition;
use Railt\Reflection\Exception\TypeNotFoundException;

/**
 * Trait HasInterfaces
 * @mixin ProvidesInterfaces
 */
trait HasInterfaces
{
    /**
     * @var array|string[]
     */
    protected $interfaces = [];

    /**
     * @param TypeDefinition $definition
     * @return bool
     */
    public function isImplementsDefinition(TypeDefinition $definition): bool
    {
        foreach ($this->getInterfaces() as $interface) {
            if ($interface->instanceOf($definition)) {
                return true;
            }
        }

        return false;
    }

    /**
     * @param string $interface
     * @return bool
     */
    public function isImplements(string $interface): bool
    {
        return $this->isImplementsDefinition($this->fetch($interface));
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
    }

    /**
     * @return iterable|InterfaceDefinition[]
     */
    public function getInterfaces(): iterable
    {
        foreach ($this->interfaces as $interface) {
            yield $this->fetch($interface);
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
        }
    }

    /**
     * @param string $name
     * @return bool
     */
    public function hasInterface(string $name): bool
    {
        return \in_array($name, $this->interfaces, true);
    }

    /**
     * @param string $name
     * @return InterfaceDefinition|null
     */
    public function getInterface(string $name): ?InterfaceDefinition
    {
        return \in_array($name, $this->interfaces, true) ? $this->fetch($name) : null;
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
    }

    /**
     * @param InterfaceDefinition ...$interfaces
     * @return ProvidesInterfaces|$this
     */
    public function implements(InterfaceDefinition ...$interfaces): ProvidesInterfaces
    {
        foreach ($interfaces as $interface) {
            $this->interfaces[] = $interface->getName();
        }

        return $this;
    }
}



1		<?php
2		/**
3		* This file is part of Railt package.
4		*
5		* For the full copyright and license information, please view the LICENSE
6		* file that was distributed with this source code.
7		*/
8		declare(strict_types=1);
9
10		namespace Railt\Reflection\Definition\Behaviour;
11
12		use Railt\Reflection\Contracts\Definition\Behaviour\ProvidesInterfaces;
13		use Railt\Reflection\Contracts\Definition\InterfaceDefinition;
14		use Railt\Reflection\Contracts\Definition\TypeDefinition;
15		use Railt\Reflection\Exception\TypeNotFoundException;
16
17		/**
18		* Trait HasInterfaces
19		* @mixin ProvidesInterfaces
20		*/
21		trait HasInterfaces
22		{
23		/**
24		* @var array\|string[]
25		*/
26		protected $interfaces = [];
27
28		/**
29		* @param TypeDefinition $definition
30		* @return bool
31		*/
32	3	public function isImplementsDefinition(TypeDefinition $definition): bool
33		{
34	3	foreach ($this->getInterfaces() as $interface) {
35		if ($interface->instanceOf($definition)) {
36		return true;
37		}
38		}
39
40	3	return false;
41		}
42
43		/**
44		* @param string $interface
45		* @return bool
46		*/
47		public function isImplements(string $interface): bool
48		{
49		return $this->isImplementsDefinition($this->fetch($interface));
		0 ignored issues – show Bug introduced 2018-07-18 23:50 UTC by Report Bug Copy Issue Report It seems like `fetch()` must be provided by classes using this trait. How about adding it as abstract method to this trait? This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable { public function equalIds(Idable $other) { return $this->getId() === $other->getId(); } } The trait `Idable` provides a method `equalsId` that in turn relies on the method `getId()`. If this method does not exist on a class mixing in this trait, the method will fail. Adding the `getId()` as an abstract method to the trait will make sure it is available. Loading history...
50		}
51
52		/**
53		* @return iterable\|InterfaceDefinition[]
54		*/
55	3	public function getInterfaces(): iterable
56		{
57	3	foreach ($this->interfaces as $interface) {
58		yield $this->fetch($interface);
		0 ignored issues – show Bug introduced 2018-07-17 01:05 UTC by Report Bug Copy Issue Report It seems like `fetch()` must be provided by classes using this trait. How about adding it as abstract method to this trait? This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable { public function equalIds(Idable $other) { return $this->getId() === $other->getId(); } } The trait `Idable` provides a method `equalsId` that in turn relies on the method `getId()`. If this method does not exist on a class mixing in this trait, the method will fail. Adding the `getId()` as an abstract method to the trait will make sure it is available. Loading history...
59		}
60	3	}
61
62		/**
63		* @param string $name
64		* @return bool
65		*/
66		public function hasInterface(string $name): bool
67		{
68		return \in_array($name, $this->interfaces, true);
69		}
70
71		/**
72		* @param string $name
73		* @return InterfaceDefinition\|null
74		*/
75		public function getInterface(string $name): ?InterfaceDefinition
76		{
77		return \in_array($name, $this->interfaces, true) ? $this->fetch($name) : null;
		0 ignored issues – show Bug introduced 2018-07-20 01:17 UTC by Report Bug Copy Issue Report It seems like `fetch()` must be provided by classes using this trait. How about adding it as abstract method to this trait? This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable { public function equalIds(Idable $other) { return $this->getId() === $other->getId(); } } The trait `Idable` provides a method `equalsId` that in turn relies on the method `getId()`. If this method does not exist on a class mixing in this trait, the method will fail. Adding the `getId()` as an abstract method to the trait will make sure it is available. Loading history...
78		}
79
80		/**
81		* @param InterfaceDefinition ...$interfaces
82		* @return ProvidesInterfaces\|$this
83		*/
84		public function implements(InterfaceDefinition ...$interfaces): ProvidesInterfaces
85		{
86		foreach ($interfaces as $interface) {
87		$this->interfaces[] = $interface->getName();
88		}
89
90		return $this;
91		}
92		}
93
94

railt / reflection

Push — master ( 3b7232...dbe410 )

HasInterfaces::getInterfaces() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like