Manager - Code Metrics - Inspection of "update libs" - tarantool-php/mapper - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 063706...c4b070 )

by Dmitry

created 2017-02-09 13:20 UTC

Manager A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	123
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	3

Test Coverage

Coverage

95.45%

Importance

Changes	1
Bugs	0	Features	1

Metric	Value
dl	0
loc	123
c	1
b	0
f	1
wmc	21
lcom	2
cbo	3
ccs	42
cts	44
cp	0.9545
rs	10

12 Methods

Rating	Name	Size	Complexity
A	__construct()	4	1
A	get()	12	3
A	forgetRepository()	6	2
A	save()	4	1
A	remove()	4	1
A	findRepository()	9	3
A	create()	4	1
A	getClient()	4	1
A	getSchema()	8	2
A	setSchema()	7	2
A	getMeta()	8	2
A	setMeta()	7	2

<?php

namespace Tarantool\Mapper;

use Tarantool\Client\Client as TarantoolClient;
use Tarantool\Mapper\Schema\Schema;
use Tarantool\Mapper\Schema\Meta;
use LogicException;

class Manager implements Contracts\Manager
{
    protected $meta;
    protected $schema;
    protected $client;
    protected $repositores = [];

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

    /**
     * @return Contracts\Repository|Contracts\Entity
     */
    public function get($type, $id = null)
    {
        if (!array_key_exists($type, $this->repositores)) {
            $this->repositores[$type] = new Repository($this->getMeta()->get($type));
        }

        if ($id) {
            return $this->repositores[$type]->find($id);
        }

        return $this->repositores[$type];
    }

    public function forgetRepository($type)
    {
        if (array_key_exists($type, $this->repositores)) {
            unset($this->repositores[$type]);
        }
    }

    /**
     * @return Contracts\Entity
     */
    public function save(Contracts\Entity $entity)
    {
        return $this->findRepository($entity)->save($entity);
    }

    /**
     * @return Contracts\Entity
     */
    public function remove(Contracts\Entity $entity)
    {
        return $this->findRepository($entity)->remove($entity);
    }

    public function findRepository(Contracts\Entity $entity)
    {
        foreach ($this->repositores as $repository) {
            if ($repository->knows($entity)) {
                return $repository;
            }
        }
        throw new LogicException('Entity should be related with repository');
    }

    /**
     * @return Contracts\Entity
     */
    public function create($type, $data = null)
    {
        return $this->save($this->get($type)->create($data));
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
    }

    /**
     * @return Client
     */
    public function getClient()
    {
        return $this->client;
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());
}
    }

    /**
     * @return Schema
     */
    public function getSchema()
    {
        if (!isset($this->schema)) {
            $this->schema = new Schema($this->getClient());
        }

        return $this->schema;
    }

    /**
     * @param Schema
     */
    public function setSchema(Contracts\Schema $schema)
    {
        if (isset($this->schema)) {
            throw new Exception("Schema is defined");
        }
        $this->schema = $schema;
    }

    /**
     * @return Meta
     */
    public function getMeta()
    {
        if (!isset($this->meta)) {
            $this->meta = new Meta($this);
        }

        return $this->meta;
    }

    /**
     * @param Meta
     */
    public function setMeta(Contracts\Meta $meta)
    {
        if (isset($this->meta)) {
            throw new Exception("Meta is defined");
        }
        $this->meta = $meta;
    }
}


1		<?php
2
3		namespace Tarantool\Mapper;
4
5		use Tarantool\Client\Client as TarantoolClient;
6		use Tarantool\Mapper\Schema\Schema;
7		use Tarantool\Mapper\Schema\Meta;
8		use LogicException;
9
10		class Manager implements Contracts\Manager
11		{
12		protected $meta;
13		protected $schema;
14		protected $client;
15		protected $repositores = [];
16
17	65	public function __construct(TarantoolClient $client)
18		{
19	65	$this->client = $client;
20	65	}
21
22		/**
23		* @return Contracts\Repository\|Contracts\Entity
24		*/
25	64	public function get($type, $id = null)
26		{
27	64	if (!array_key_exists($type, $this->repositores)) {
28	64	$this->repositores[$type] = new Repository($this->getMeta()->get($type));
29		}
30
31	64	if ($id) {
32	12	return $this->repositores[$type]->find($id);
33		}
34
35	64	return $this->repositores[$type];
36		}
37
38	2	public function forgetRepository($type)
39		{
40	2	if (array_key_exists($type, $this->repositores)) {
41	1	unset($this->repositores[$type]);
42		}
43	2	}
44
45		/**
46		* @return Contracts\Entity
47		*/
48	64	public function save(Contracts\Entity $entity)
49		{
50	64	return $this->findRepository($entity)->save($entity);
51		}
52
53		/**
54		* @return Contracts\Entity
55		*/
56	6	public function remove(Contracts\Entity $entity)
57		{
58	6	return $this->findRepository($entity)->remove($entity);
59		}
60
61	64	public function findRepository(Contracts\Entity $entity)
62		{
63	64	foreach ($this->repositores as $repository) {
64	64	if ($repository->knows($entity)) {
65	64	return $repository;
66		}
67		}
68	1	throw new LogicException('Entity should be related with repository');
69		}
70
71		/**
72		* @return Contracts\Entity
73		*/
74	64	public function create($type, $data = null)
75		{
76	64	return $this->save($this->get($type)->create($data));
		0 ignored issues – show Bug introduced 2016-04-04 18:16 UTC by Report Bug Copy Issue Report The method `create` does only exist in `Tarantool\Mapper\Contracts\Repository`, but not in `Tarantool\Mapper\Contracts\Entity`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
77		}
78
79		/**
80		* @return Client
81		*/
82	65	public function getClient()
83		{
84	65	return $this->client;
		0 ignored issues – show Bug Best Practice introduced 2016-11-30 21:20 UTC by Report Bug Copy Issue Report The return type of `return $this->client;` (`Tarantool\Client\Client`) is incompatible with the return type declared by the interface `Tarantool\Mapper\Contracts\Manager::getClient` of type `Tarantool\Client`. 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...
85		}
86
87		/**
88		* @return Schema
89		*/
90	64	public function getSchema()
91		{
92	64	if (!isset($this->schema)) {
93	64	$this->schema = new Schema($this->getClient());
94		}
95
96	64	return $this->schema;
97		}
98
99		/**
100		* @param Schema
101		*/
102	1	public function setSchema(Contracts\Schema $schema)
103		{
104	1	if (isset($this->schema)) {
105		throw new Exception("Schema is defined");
106		}
107	1	$this->schema = $schema;
108	1	}
109
110		/**
111		* @return Meta
112		*/
113	64	public function getMeta()
114		{
115	64	if (!isset($this->meta)) {
116	64	$this->meta = new Meta($this);
117		}
118
119	64	return $this->meta;
120		}
121
122		/**
123		* @param Meta
124		*/
125	1	public function setMeta(Contracts\Meta $meta)
126		{
127	1	if (isset($this->meta)) {
128		throw new Exception("Meta is defined");
129		}
130	1	$this->meta = $meta;
131	1	}
132		}
133

tarantool-php / mapper

Push — master ( 063706...c4b070 )

Manager A

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

12 Methods

Available Fixes

Duplication Side-by-Side

Filter issues like