HasDefinitions::withoutDefinition() - Code Metrics - Inspection of "Merge pull request #1 from greabock/master" - railt/reflection - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Push — master ( 97fe68...3f86cd )

by Kirill

created 2018-10-29 19:40 UTC

HasDefinitions::withoutDefinition() A

↳ Parent: HasDefinitions

Complexity

Conditions	3
Paths	3

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	12

Importance

Changes

Metric	Value
dl	0
loc	10
ccs	0
cts	5
cp	0
rs	9.9332
c	0
b	0
f	0
cc	3
nc	3
nop	1
crap	12

<?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\ProvidesTypeDefinitions;
use Railt\Reflection\Contracts\Definition\TypeDefinition;

/**
 * Trait HasDefinitions
 */
trait HasDefinitions
{
    /**
     * @var array|string[]
     */
    protected $types = [];

    /**
     * @param string|TypeDefinition $type
     * @return TypeDefinition
     */
    abstract protected function fetch($type): TypeDefinition;

    /**
     * @return iterable|TypeDefinition[]
     */
    public function getDefinitions(): iterable
    {
        foreach ($this->types as $type) {
            yield $this->fetch($type);
        }
    }

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

    /**
     * @param string $name
     * @return null|TypeDefinition
     */
    public function getDefinition(string $name): ?TypeDefinition
    {
        if (! \in_array($name, $this->types, true)) {
            return null;
        }

        return $this->fetch($name);
    }

    /**
     * @param string|TypeDefinition ...$types
     * @return ProvidesTypeDefinitions|$this
     */
    public function withDefinition(...$types): ProvidesTypeDefinitions
    {
        foreach ($types as $type) {
            $this->types[] = $this->nameOf($type);
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
        }

        return $this;
    }

    /**
     * @param string|TypeDefinition ...$types
     * @return ProvidesTypeDefinitions|$this
     */
    public function withoutDefinition(...$types): ProvidesTypeDefinitions
    {
        foreach ($types as $type) {
            if ($this->hasDefinition($this->nameOf($type))) {
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
                array_splice($this->types, array_search($this->types, $this->nameOf($type)), 1);
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
            }
        }

        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\ProvidesTypeDefinitions;
13		use Railt\Reflection\Contracts\Definition\TypeDefinition;
14
15		/**
16		* Trait HasDefinitions
17		*/
18		trait HasDefinitions
19		{
20		/**
21		* @var array\|string[]
22		*/
23		protected $types = [];
24
25		/**
26		* @param string\|TypeDefinition $type
27		* @return TypeDefinition
28		*/
29		abstract protected function fetch($type): TypeDefinition;
30
31		/**
32		* @return iterable\|TypeDefinition[]
33		*/
34	3	public function getDefinitions(): iterable
35		{
36	3	foreach ($this->types as $type) {
37	2	yield $this->fetch($type);
38		}
39	3	}
40
41		/**
42		* @param string $name
43		* @return bool
44		*/
45	5	public function hasDefinition(string $name): bool
46		{
47	5	return \in_array($name, $this->types, true);
48		}
49
50		/**
51		* @param string $name
52		* @return null\|TypeDefinition
53		*/
54	3	public function getDefinition(string $name): ?TypeDefinition
55		{
56	3	if (! \in_array($name, $this->types, true)) {
57	1	return null;
58		}
59
60	2	return $this->fetch($name);
61		}
62
63		/**
64		* @param string\|TypeDefinition ...$types
65		* @return ProvidesTypeDefinitions\|$this
66		*/
67	17	public function withDefinition(...$types): ProvidesTypeDefinitions
68		{
69	17	foreach ($types as $type) {
70	17	$this->types[] = $this->nameOf($type);
		0 ignored issues – show Bug introduced 2018-08-06 10:27 UTC by Report Bug Copy Issue Report It seems like `nameOf()` 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...
71		}
72
73	17	return $this;
74		}
75
76		/**
77		* @param string\|TypeDefinition ...$types
78		* @return ProvidesTypeDefinitions\|$this
79		*/
80		public function withoutDefinition(...$types): ProvidesTypeDefinitions
81		{
82		foreach ($types as $type) {
83		if ($this->hasDefinition($this->nameOf($type))) {
		0 ignored issues – show Bug introduced 2018-10-29 11:08 UTC by Report Bug Copy Issue Report It seems like `nameOf()` 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...
84		array_splice($this->types, array_search($this->types, $this->nameOf($type)), 1);
		0 ignored issues – show Bug introduced 2018-10-29 11:08 UTC by Report Bug Copy Issue Report It seems like `nameOf()` 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...
85		}
86		}
87
88		return $this;
89		}
90		}
91

railt / reflection

Push — master ( 97fe68...3f86cd )

HasDefinitions::withoutDefinition() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like