BaseDocument - Code Metrics - Inspection of "Merge branch 'master' of github.com:railt/sdl" - railt/sdl - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 5ac91e...39483e )

by Kirill

created 2018-05-05 20:22 UTC

BaseDocument A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	139
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	3

Test Coverage

Coverage

88.89%

Importance

Changes

Metric	Value
wmc	14
lcom	2
cbo	3
dl	0
loc	139
ccs	24
cts	27
cp	0.8889
rs	10
c	0
b	0
f	0

11 Methods

Rating	Name	Size	Complexity
A	getSchema()	12	4
A	getTypeDefinitions()	4	1
A	getTypeDefinition()	4	1
A	hasTypeDefinition()	4	1
A	getNumberOfTypeDefinitions()	4	1
A	getDefinitions()	4	1
A	getFile()	4	1
A	getFileName()	4	1
A	getContents()	4	1
A	__sleep()	16	1
A	getTypeName()	4	1

<?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\SDL\Base;

use Railt\Io\Readable;
use Railt\SDL\Base\Definitions\BaseDefinition;
use Railt\SDL\Base\Invocations\Directive\BaseDirectivesContainer;
use Railt\SDL\Contracts\Definitions\Definition;
use Railt\SDL\Contracts\Definitions\SchemaDefinition;
use Railt\SDL\Contracts\Definitions\TypeDefinition;
use Railt\SDL\Contracts\Document;
use Railt\SDL\Contracts\Type;

/**
 * Class BaseDocument
 */
abstract class BaseDocument extends BaseDefinition implements Document
{
    use BaseDirectivesContainer;

    /**
     * Document type name
     */
    protected const TYPE_NAME = Type::DOCUMENT;

    /**
     * @var SchemaDefinition|null
     */
    private $schema;

    /**
     * @var array|TypeDefinition[]
     */
    protected $types = [];

    /**
     * @var array|Definition[]
     */
    protected $definitions = [];

    /**
     * @var Readable
     */
    protected $file;

    /**
     * @return null|SchemaDefinition
     */
    public function getSchema(): ?SchemaDefinition
    {
        if ($this->schema === null) {
            foreach ($this->types as $type) {
                if ($type instanceof SchemaDefinition) {
                    return $this->schema = $type;
                }
            }
        }

        return $this->schema;
    }

    /**
     * @return iterable
     */
    public function getTypeDefinitions(): iterable
    {
        return \array_values($this->types);
class Author {
    private $name;

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

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
    }

    /**
     * @param string $name
     * @return null|TypeDefinition
     */
    public function getTypeDefinition(string $name): ?TypeDefinition
    {
        return $this->types[$name] ?? null;
    }

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

    /**
     * @return int
     */
    public function getNumberOfTypeDefinitions(): int
    {
        return \count($this->types);
    }

    /**
     * @return iterable
     */
    public function getDefinitions(): iterable
    {
        return \array_values(\array_merge($this->types, $this->definitions));
    }

    /**
     * @return Readable
     */
    public function getFile(): Readable
    {
        return $this->file;
    }

    /**
     * @return string
     */
    final public function getFileName(): string
    {
        return $this->file->getPathname();
    }

    /**
     * @return string
     */
    public function getContents(): string
    {
        return $this->file->getContents();
    }

    /**
     * @return array
     */
    public function __sleep(): array
    {
        return \array_merge(parent::__sleep(), [
            // File
            'file',

            // instanceof TypeDefinition
            'types',

            // instanceof Definition
            'definitions',

            // Directives
            'directives',
        ]);
    }

    /**
     * @return string
     */
    public function getTypeName(): string
    {
        return self::TYPE_NAME;
    }
}


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\SDL\Base;
11
12		use Railt\Io\Readable;
13		use Railt\SDL\Base\Definitions\BaseDefinition;
14		use Railt\SDL\Base\Invocations\Directive\BaseDirectivesContainer;
15		use Railt\SDL\Contracts\Definitions\Definition;
16		use Railt\SDL\Contracts\Definitions\SchemaDefinition;
17		use Railt\SDL\Contracts\Definitions\TypeDefinition;
18		use Railt\SDL\Contracts\Document;
19		use Railt\SDL\Contracts\Type;
20
21		/**
22		* Class BaseDocument
23		*/
24		abstract class BaseDocument extends BaseDefinition implements Document
25		{
26		use BaseDirectivesContainer;
27
28		/**
29		* Document type name
30		*/
31		protected const TYPE_NAME = Type::DOCUMENT;
32
33		/**
34		* @var SchemaDefinition\|null
35		*/
36		private $schema;
37
38		/**
39		* @var array\|TypeDefinition[]
40		*/
41		protected $types = [];
42
43		/**
44		* @var array\|Definition[]
45		*/
46		protected $definitions = [];
47
48		/**
49		* @var Readable
50		*/
51		protected $file;
52
53		/**
54		* @return null\|SchemaDefinition
55		*/
56	48	public function getSchema(): ?SchemaDefinition
57		{
58	48	if ($this->schema === null) {
59	48	foreach ($this->types as $type) {
60	48	if ($type instanceof SchemaDefinition) {
61	48	return $this->schema = $type;
62		}
63		}
64		}
65
66		return $this->schema;
67		}
68
69		/**
70		* @return iterable
71		*/
72	7189	public function getTypeDefinitions(): iterable
73		{
74	7189	return \array_values($this->types);
		0 ignored issues – show Bug Best Practice introduced 2018-05-05 21:00 UTC by Report Bug Copy Issue Report The return type of `return \array_values($this->types);` (`array`) is incompatible with the return type declared by the interface `Railt\SDL\Contracts\Document::getTypeDefinitions` of type `Railt\SDL\Contracts\iter...itions\TypeDefinition[]`. If you return a value from a function or method, it should be a sub-type of the type that is given by the parent type f.e. an interface, or abstract method. This is more formally defined by the Lizkov substitution principle, and guarantees that classes that depend on the parent type can use any instance of a child type interchangably. This principle also belongs to the SOLID principles for object oriented design. Let’s take a look at an example: class Author { private $name; public function __construct($name) { $this->name = $name; } public function getName() { return $this->name; } } abstract class Post { public function getAuthor() { return 'Johannes'; } } class BlogPost extends Post { public function getAuthor() { return new Author('Johannes'); } } class ForumPost extends Post { /* ... */ } function my_function(Post $post) { echo strtoupper($post->getAuthor()); } Our function `my_function` expects a `Post` object, and outputs the author of the post. The base class `Post` returns a simple string and outputting a simple string will work just fine. However, the child class `BlogPost` which is a sub-type of `Post` instead decided to return an `object`, and is therefore violating the SOLID principles. If a `BlogPost` were passed to `my_function`, PHP would not complain, but ultimately fail when executing the `strtoupper` call in its body. Loading history...
75		}
76
77		/**
78		* @param string $name
79		* @return null\|TypeDefinition
80		*/
81	307	public function getTypeDefinition(string $name): ?TypeDefinition
82		{
83	307	return $this->types[$name] ?? null;
84		}
85
86		/**
87		* @param string $name
88		* @return bool
89		*/
90	18	public function hasTypeDefinition(string $name): bool
91		{
92	18	return \array_key_exists($name, $this->types);
93		}
94
95		/**
96		* @return int
97		*/
98	18	public function getNumberOfTypeDefinitions(): int
99		{
100	18	return \count($this->types);
101		}
102
103		/**
104		* @return iterable
105		*/
106	7165	public function getDefinitions(): iterable
107		{
108	7165	return \array_values(\array_merge($this->types, $this->definitions));
109		}
110
111		/**
112		* @return Readable
113		*/
114	3651	public function getFile(): Readable
115		{
116	3651	return $this->file;
117		}
118
119		/**
120		* @return string
121		*/
122	3651	final public function getFileName(): string
123		{
124	3651	return $this->file->getPathname();
125		}
126
127		/**
128		* @return string
129		*/
130		public function getContents(): string
131		{
132		return $this->file->getContents();
133		}
134
135		/**
136		* @return array
137		*/
138	1257	public function __sleep(): array
139		{
140	1257	return \array_merge(parent::__sleep(), [
141		// File
142	1257	'file',
143
144		// instanceof TypeDefinition
145		'types',
146
147		// instanceof Definition
148		'definitions',
149
150		// Directives
151		'directives',
152		]);
153		}
154
155		/**
156		* @return string
157		*/
158	66	public function getTypeName(): string
159		{
160	66	return self::TYPE_NAME;
161		}
162		}
163

railt / sdl

Push — master ( 5ac91e...39483e )

BaseDocument A

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

11 Methods

Duplication Side-by-Side

Filter issues like