Repository - Code Metrics - Inspection of "implement compute plugin" - tarantool-php/mapper - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( fc9daa...0ac164 )

by Dmitry

created 2017-12-14 16:59 UTC

Repository D

↳ Parent: Project

Complexity

Total Complexity

109

Size/Duplication

Total Lines	471
Duplicated Lines	8.92 %

Coupling/Cohesion

Components	1
Dependencies	5

Test Coverage

Coverage

98.48%

Importance

Changes

Metric	Value
wmc	109
lcom	1
cbo	5
dl	42
loc	471
rs	4.8717
c	0
b	0
f	0
ccs	194
cts	197
cp	0.9848

21 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	findOne()	0	4	1
A	findOrCreate()	0	8	2
A	findOrFail()	0	8	2
C	create()	9	68	18
C	find()	0	60	16
A	forget()	0	6	2
C	getInstance()	12	35	8
A	getMapper()	0	4	1
A	getSpace()	0	4	1
A	knows()	0	4	1
C	update()	5	27	7
A	truncate()	0	6	1
A	remove()	0	14	4
C	removeEntity()	3	42	8
D	save()	13	89	20
A	addDefaultValues()	0	12	3
A	getOriginal()	0	4	1
B	getTuple()	0	23	5
B	sync()	0	14	6
A	flushCache()	0	4	1

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like Repository often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use Repository, and based on these observations, apply Extract Interface, too.

<?php

namespace Tarantool\Mapper;

use Exception;
use SplObjectStorage;

class Repository
{
    private $space;
    private $persisted = [];
    private $original = [];
    private $keys;

    private $results = [];

    public function __construct(Space $space)
    {
        $this->space = $space;
        $this->keys = new SplObjectStorage;
    }

    public function create($data)
    {
        $data = (array) $data;
        $class = Entity::class;
        foreach ($this->getMapper()->getPlugins() as $plugin) {

            $entityClass = $plugin->getEntityClass($this->space);
            if ($entityClass) {
                if ($class != Entity::class) {
                    throw new Exception('Entity class override');
                }
                $class = $entityClass;
            }
        }

        if (array_key_exists(0, $data)) {
            $byType = [];
            foreach ($this->space->getFormat() as $row) {
                if (!array_key_exists($row['type'], $byType)) {
                    $byType[$row['type']] = [$row['name']];
                } else {
                    $byType[$row['type']][] = $row['name'];
                }
            }
            $mapping = [
                'is_numeric' => 'unsigned',
                'is_string' => 'string',
                'is_array' => '*',
            ];
            foreach ($data as $k => $v) {
                foreach ($mapping as $function => $type) {
                    if (call_user_func($function, $v)) {
                        if (array_key_exists($type, $byType) && count($byType[$type]) == 1) {
                            $data[$byType[$type][0]] = $v;
                            unset($data[$k]);
                        }
                    }
                }
            }
        }

        $instance = new $class($this);

        foreach ($this->space->getFormat() as $row) {
            if (array_key_exists($row['name'], $data)) {
                $instance->{$row['name']} = $data[$row['name']];
                if ($data[$row['name']] instanceof Entity) {
                    $instance->{$row['name']} = $instance->{$row['name']}->id;
                }
            }
        }

        foreach ($this->getMapper()->getPlugins() as $plugin) {
            $plugin->generateKey($instance, $this->space);
            $plugin->afterInstantiate($instance, $this->space);
        }

        // validate instance key
        $key = $this->space->getInstanceKey($instance);

        foreach ($this->keys as $_) {
            if ($this->keys[$_] == $key) {
                throw new Exception($this->space->getName().' '.json_encode($key).' exists');
            }
        }

        $this->keys[$instance] = $key;
        return $instance;
    }

    public function findOne($params = [])
    {
        return $this->find($params, true);
    }

    public function findOrCreate($params = [])
    {
        $entity = $this->findOne($params);
        if (!$entity) {
            $entity = $this->create($params);
        }
        return $entity;
    }

    public function findOrFail($params = [])
    {
        $entity = $this->findOne($params);
        if (!$entity) {
            throw new Exception("No ".$this->getSpace()->getName().' found using '.json_encode($params));
        }
        return $entity;
    }

    public function find($params = [], $one = false)
    {
        $cacheKey = json_encode(func_get_args());

        if (array_key_exists($cacheKey, $this->results)) {
            return $this->results[$cacheKey];
        }

        if (!is_array($params)) {
            $params = [$params];
        }
        if (count($params) == 1 && array_key_exists(0, $params)) {
            $primary = $this->space->getPrimaryIndex();
            if (count($primary['parts']) == 1) {
                $formatted = $this->getMapper()->getSchema()->formatValue($primary['parts'][0][1], $params[0]);
                if ($params[0] == $formatted) {
                    $params = [
                        $this->space->getFormat()[$primary['parts'][0][0]]['name'] => $params[0]
                    ];
                }
            }
        }

        if (array_key_exists('id', $params)) {
            if (array_key_exists($params['id'], $this->persisted)) {
                $instance = $this->persisted[$params['id']];
                return $one ? $instance : [$instance];
            }
        }


        $index = $this->space->castIndex($params);
        if (is_null($index)) {
            throw new Exception("No index for params ".json_encode($params));
        }

        $client = $this->getMapper()->getClient();
        $values = $this->space->getIndexValues($index, $params);
        if ($this->space->getIndextype($index) == 'hash' && !count($values)) {
            //  iterator box.index.ALL == 2
            $data = $client->getSpace($this->space->getId())->select($values, $index, null, null, 2)->getData();
        } else {
            $data = $client->getSpace($this->space->getId())->select($values, $index)->getData();
        }

        $result = [];
        foreach ($data as $tuple) {
$collection = json_decode($data, true);
if ( ! is_array($collection)) {
    throw new \RuntimeException('$collection must be an array.');
}

foreach ($collection as $item) { /** ... */ }
            $instance = $this->getInstance($tuple);
            if ($one) {
                return $this->results[$cacheKey] = $instance;
            }
            $result[] = $instance;
        }

        if ($one) {
            return $this->results[$cacheKey] = null;
        }

        return $this->results[$cacheKey] = $result;
    }

    public function forget($id)
    {
        if (array_key_exists($id, $this->persisted)) {
            unset($this->persisted[$id]);
        }
    }

    public function getInstance($tuple)
    {
        $key = $this->space->getTupleKey($tuple);

        if (array_key_exists($key, $this->persisted)) {
            return $this->persisted[$key];
        }

        $class = Entity::class;
        foreach ($this->getMapper()->getPlugins() as $plugin) {

            $entityClass = $plugin->getEntityClass($this->space);
            if ($entityClass) {
                if ($class != Entity::class) {
                    throw new Exception('Entity class override');
                }
                $class = $entityClass;
            }
        }

        $instance = new $class($this);

        $this->original[$key] = $tuple;

        foreach ($this->space->getFormat() as $index => $info) {

            $instance->{$info['name']} = array_key_exists($index, $tuple) ? $tuple[$index] : null;
        }

        $this->keys->offsetSet($instance, $key);

        foreach ($this->getMapper()->getPlugins() as $plugin) {
            $plugin->afterInstantiate($instance);
        }

        return $this->persisted[$key] = $instance;
    }

    public function getMapper()
    {
        return $this->space->getMapper();
    }

    public function getSpace()
    {
        return $this->space;
    }

    public function knows($instance)
    {
        return $this->keys->offsetExists($instance);
    }

    public function update(Entity $instance, $operations)
    {
        if (!count($operations)) {
            return;
        }

        $tupleOperations = [];
        foreach ($operations as $operation) {
            $tupleIndex = $this->space->getPropertyIndex($operation[1]);
            $tupleOperations[] = [$operation[0], $tupleIndex, $operation[2]];
        }

        $pk = [];
        foreach ($this->space->getPrimaryIndex()['parts'] as $part) {
            $pk[] = $instance->{$this->space->getFormat()[$part[0]]['name']};
        }

        $client = $this->getMapper()->getClient();
        $result = $client->getSpace($this->space->getId())->update($pk, $tupleOperations);
        foreach ($result->getData() as $tuple) {
            foreach ($this->space->getFormat() as $index => $info) {

                if (array_key_exists($index, $tuple)) {
                    $instance->{$info['name']} = $tuple[$index];
                }
            }
        }
    }

    public function truncate()
    {
        $this->results = [];
        $id = $this->space->getId();
        $this->getMapper()->getClient()->evaluate("box.space[$id]:truncate()");
    }

    public function remove($params = [])
    {
        if ($params instanceof Entity) {
            return $this->removeEntity($params);
        }

        if (!count($params)) {
            throw new Exception("Use truncate to flush space");
        }

        foreach ($this->find($params) as $entity) {
            $this->removeEntity($entity);
        }
    }

    public function removeEntity(Entity $instance)
    {
        $key = $this->space->getInstanceKey($instance);

        if (!array_key_exists($key, $this->original)) {
            return;
        }

        if (array_key_exists($key, $this->persisted)) {
            unset($this->persisted[$key]);

            $pk = [];
            foreach ($this->space->getPrimaryIndex()['parts'] as $part) {

                $pk[] = $this->original[$key][$part[0]];
            }

            foreach ($this->getMapper()->getPlugins() as $plugin) {
                $plugin->beforeRemove($instance, $this->space);
            }

            if (method_exists($instance, 'beforeRemove')) {
                $instance->beforeRemove();
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
            }

            $this->getMapper()->getClient()
                ->getSpace($this->space->getId())
                ->delete($pk);

            foreach ($this->getMapper()->getPlugins() as $plugin) {
                $plugin->afterRemove($instance, $this->space);
            }

            if (method_exists($instance, 'afterRemove')) {
                $instance->afterRemove();
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
            }
        }

        unset($this->original[$key]);
        unset($this->keys[$instance]);

        $this->results = [];
    }

    public function save($instance)
    {
        $key = $this->space->getInstanceKey($instance);
        $client = $this->getMapper()->getClient();

        if (array_key_exists($key, $this->persisted)) {
            // update
            $tuple = $this->getTuple($instance);
            $update = [];

            foreach ($tuple as $i => $v) {

                if (!array_key_exists($i, $this->original[$key]) || $v !== $this->original[$key][$i]) {
                    $update[$i] = $v;
                }
            }

            if (!count($update)) {
                return $instance;
            }

            foreach ($this->getMapper()->getPlugins() as $plugin) {
                $plugin->beforeUpdate($instance, $this->space);
            }

            if (method_exists($instance, 'beforeUpdate')) {
                $instance->beforeUpdate();
            }

            $tuple = $this->getTuple($instance);
            $update = [];

            foreach ($tuple as $i => $v) {

                if (!array_key_exists($i, $this->original[$key]) || $v !== $this->original[$key][$i]) {
                    $update[$i] = $v;
                }
            }

            if (!count($update)) {
                return $instance;
            }

            $operations = [];
            foreach ($update as $index => $value) {
                $operations[] = ['=', $index, $value];
            }

            $pk = [];
            foreach ($this->space->getPrimaryIndex()['parts'] as $part) {

                $pk[] = $this->original[$key][$part[0]];
            }

            $client->getSpace($this->space->getId())->update($pk, $operations);
            $this->original[$key] = $tuple;

            foreach ($this->getMapper()->getPlugins() as $plugin) {
                $plugin->afterUpdate($instance, $this->space);
            }

            if (method_exists($instance, 'afterUpdate')) {
                $instance->afterUpdate();
            }
        } else {
            $this->addDefaultValues($instance);
            foreach ($this->getMapper()->getPlugins() as $plugin) {
                $plugin->beforeCreate($instance, $this->space);
            }

            if (method_exists($instance, 'beforeCreate')) {
                $instance->beforeCreate();
            }

            $tuple = $this->getTuple($instance);
            $client->getSpace($this->space->getId())->insert($tuple);
            $this->persisted[$key] = $instance;
            $this->original[$key] = $tuple;

            foreach ($this->getMapper()->getPlugins() as $plugin) {
                $plugin->afterCreate($instance, $this->space);
            }

            if (method_exists($instance, 'afterCreate')) {
                $instance->afterCreate();
            }
        }

        $this->flushCache();

        return $instance;
    }

    private function addDefaultValues(Entity $instance)
    {
        $format = $this->space->getFormat();

        // complete format fields
        foreach ($format as $info) {
            $name = $info['name'];
            if (!property_exists($instance, $name)) {
                $instance->$name = null;
            }
        }
    }

    public function getOriginal($instance)
    {
        return $this->original[$this->space->getInstanceKey($instance)];
    }

    private function getTuple(Entity $instance)
    {
        $schema = $this->getMapper()->getSchema();
        $tuple = [];

        foreach ($this->space->getFormat() as $index => $info) {
            $name = $info['name'];
            if (!property_exists($instance, $name)) {
                $instance->$name = null;
            }

            $instance->$name = $schema->formatValue($info['type'], $instance->$name);
            if (is_null($instance->$name)) {
                if (!$this->space->isPropertyNullable($name)) {
                    $instance->$name = $schema->getDefaultValue($info['type']);
                }
            }

            $tuple[$index] = $instance->$name;
        }

        return $tuple;
    }

    public function sync($id, $fields = null)
    {
        if (array_key_exists($id, $this->persisted)) {
            $tuple = $this->getMapper()->getClient()->getSpace($this->space->getId())->select([$id], 0)->getData()[0];

            foreach ($this->space->getFormat() as $index => $info) {
                if (!$fields || in_array($info['name'], $fields)) {
                    $value = array_key_exists($index, $tuple) ? $tuple[$index] : null;
                    $this->persisted[$id]->{$info['name']} = $value;
                    $this->original[$id][$index] = $value;
                }
            }
        }
    }

    public function flushCache()
    {
        $this->results = [];
    }
}


1			<?php
2
3			namespace Tarantool\Mapper;
4
5			use Exception;
6			use SplObjectStorage;
7
8			class Repository
9			{
10			private $space;
11			private $persisted = [];
12			private $original = [];
13			private $keys;
14
15			private $results = [];
16
17			public function __construct(Space $space)
18			{
19			$this->space = $space;
20			$this->keys = new SplObjectStorage;
21			}
22
23	64		public function create($data)
24			{
25	64		$data = (array) $data;
26	64		$class = Entity::class;
27		View Code Duplication	foreach ($this->getMapper()->getPlugins() as $plugin) {
			0 ignored issues – show Duplication introduced 2017-04-06 10:52 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
28	64		$entityClass = $plugin->getEntityClass($this->space);
29			if ($entityClass) {
30	64		if ($class != Entity::class) {
31	64		throw new Exception('Entity class override');
32			}
33			$class = $entityClass;
34	64		}
35	2		}
36
37			if (array_key_exists(0, $data)) {
38	64		$byType = [];
39	64		foreach ($this->space->getFormat() as $row) {
40	64		if (!array_key_exists($row['type'], $byType)) {
41	64		$byType[$row['type']] = [$row['name']];
42	4		} else {
43	4		$byType[$row['type']][] = $row['name'];
44			}
45	64		}
46	64		$mapping = [
47	64		'is_numeric' => 'unsigned',
48	64		'is_string' => 'string',
49			'is_array' => '*',
50			];
51	64		foreach ($data as $k => $v) {
52	64		foreach ($mapping as $function => $type) {
53			if (call_user_func($function, $v)) {
54	1		if (array_key_exists($type, $byType) && count($byType[$type]) == 1) {
55			$data[$byType[$type][0]] = $v;
56			unset($data[$k]);
57			}
58	64		}
59	2		}
60	2		}
61			}
62	64
63			$instance = new $class($this);
64	64
65	64		foreach ($this->space->getFormat() as $row) {
66	64		if (array_key_exists($row['name'], $data)) {
67	64		$instance->{$row['name']} = $data[$row['name']];
68	64		if ($data[$row['name']] instanceof Entity) {
69			$instance->{$row['name']} = $instance->{$row['name']}->id;
70			}
71			}
72	64		}
73
74	64		foreach ($this->getMapper()->getPlugins() as $plugin) {
75			$plugin->generateKey($instance, $this->space);
76			$plugin->afterInstantiate($instance, $this->space);
77	64		}
78
79	64		// validate instance key
80			$key = $this->space->getInstanceKey($instance);
81	64
82			foreach ($this->keys as $_) {
83			if ($this->keys[$_] == $key) {
84	64		throw new Exception($this->space->getName().' '.json_encode($key).' exists');
85			}
86	64		}
87	64
88	64		$this->keys[$instance] = $key;
89	64		return $instance;
90			}
91	64
92			public function findOne($params = [])
93			{
94			return $this->find($params, true);
95	1		}
96
97			public function findOrCreate($params = [])
98	19		{
99			$entity = $this->findOne($params);
100	19		if (!$entity) {
101			$entity = $this->create($params);
102			}
103	64		return $entity;
104			}
105	64
106			public function findOrFail($params = [])
107	64		{
108	1		$entity = $this->findOne($params);
109			if (!$entity) {
110			throw new Exception("No ".$this->getSpace()->getName().' found using '.json_encode($params));
111	64		}
112	10		return $entity;
113	3		}
114
115			public function find($params = [], $one = false)
116	7		{
117			$cacheKey = json_encode(func_get_args());
118	7
119			if (array_key_exists($cacheKey, $this->results)) {
120			return $this->results[$cacheKey];
121	64		}
122	2
123			if (!is_array($params)) {
124			$params = [$params];
125	64		}
126	64		if (count($params) == 1 && array_key_exists(0, $params)) {
127			$primary = $this->space->getPrimaryIndex();
128	64		if (count($primary['parts']) == 1) {
129	64		$formatted = $this->getMapper()->getSchema()->formatValue($primary['parts'][0][1], $params[0]);
130	18		if ($params[0] == $formatted) {
131	64		$params = [
132			$this->space->getFormat()[$primary['parts'][0][0]]['name'] => $params[0]
133			];
134			}
135	64		}
136	1		}
137
138			if (array_key_exists('id', $params)) {
139	64		if (array_key_exists($params['id'], $this->persisted)) {
140	64		$instance = $this->persisted[$params['id']];
141	2		return $one ? $instance : [$instance];
142	2		}
143			}
144	64
145	64
146			$index = $this->space->castIndex($params);
147	1		if (is_null($index)) {
148	64		throw new Exception("No index for params ".json_encode($params));
149			}
150
151			$client = $this->getMapper()->getClient();
152			$values = $this->space->getIndexValues($index, $params);
153	64		if ($this->space->getIndextype($index) == 'hash' && !count($values)) {
154	64		// iterator box.index.ALL == 2
155	64		$data = $client->getSpace($this->space->getId())->select($values, $index, null, null, 2)->getData();
156			} else {
157			$data = $client->getSpace($this->space->getId())->select($values, $index)->getData();
158	64		}
159	64
160	2		$result = [];
161			foreach ($data as $tuple) {
			0 ignored issues – show Bug introduced 2017-03-05 20:54 UTC by Report Bug Copy Issue Report The expression `$data` of type `null\|array` is not guaranteed to be traversable. How about adding an additional type check? There are different options of fixing this problem. If you want to be on the safe side, you can add an additional type-check: $collection = json_decode($data, true); if ( ! is_array($collection)) { throw new \RuntimeException('$collection must be an array.'); } foreach ($collection as $item) { /** ... / } If you are sure that the expression is traversable, you might want to add a doc comment cast* to improve IDE auto-completion and static analysis: /** @var array $collection / $collection = json_decode($data, true); foreach ($collection as $item) { /* .. / } Mark the issue as a false-positive*: Just hover the remove button, in the top-right corner of this issue for more options. Loading history...
162			$instance = $this->getInstance($tuple);
163	64		if ($one) {
164			return $this->results[$cacheKey] = $instance;
165	64		}
166	1		$result[] = $instance;
167	1		}
168	1
169	1		if ($one) {
170	1		return $this->results[$cacheKey] = null;
171			}
172
173	1		return $this->results[$cacheKey] = $result;
174			}
175
176	1		public function forget($id)
177			{
178	1		if (array_key_exists($id, $this->persisted)) {
179	1		unset($this->persisted[$id]);
180			}
181	1		}
182
183			public function getInstance($tuple)
184	64		{
185			$key = $this->space->getTupleKey($tuple);
186	64
187	64		if (array_key_exists($key, $this->persisted)) {
188	64		return $this->persisted[$key];
189	64		}
190	64
191	64		$class = Entity::class;
192	64	View Code Duplication	foreach ($this->getMapper()->getPlugins() as $plugin) {
			0 ignored issues – show Duplication introduced 2017-04-06 10:52 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
193			$entityClass = $plugin->getEntityClass($this->space);
194	64		if ($entityClass) {
195			if ($class != Entity::class) {
196	64		throw new Exception('Entity class override');
197	64		}
198			$class = $entityClass;
199	14		}
200			}
201
202	64		$instance = new $class($this);
203	64
204			$this->original[$key] = $tuple;
205	17
206		View Code Duplication	foreach ($this->space->getFormat() as $index => $info) {
			0 ignored issues – show Duplication introduced 2017-04-06 10:52 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
207			$instance->{$info['name']} = array_key_exists($index, $tuple) ? $tuple[$index] : null;
208			}
209
210			$this->keys->offsetSet($instance, $key);
211
212	64		foreach ($this->getMapper()->getPlugins() as $plugin) {
213			$plugin->afterInstantiate($instance);
214	64		}
215
216			return $this->persisted[$key] = $instance;
217	6		}
218
219	6		public function getMapper()
220	6		{
221	6		return $this->space->getMapper();
222			}
223	6
224	6		public function getSpace()
225			{
226	1		return $this->space;
227			}
228	1
229	1		public function knows($instance)
230	1		{
231			return $this->keys->offsetExists($instance);
232	1		}
233	1
234			public function update(Entity $instance, $operations)
235	64		{
236			if (!count($operations)) {
237	64		return;
238	64		}
239
240	64		$tupleOperations = [];
241			foreach ($operations as $operation) {
242	64		$tupleIndex = $this->space->getPropertyIndex($operation[1]);
243	1		$tupleOperations[] = [$operation[0], $tupleIndex, $operation[2]];
244			}
245
246	64		$pk = [];
247	64		foreach ($this->space->getPrimaryIndex()['parts'] as $part) {
248	64		$pk[] = $instance->{$this->space->getFormat()[$part[0]]['name']};
249	64		}
250
251	19		$client = $this->getMapper()->getClient();
252	19		$result = $client->getSpace($this->space->getId())->update($pk, $tupleOperations);
253	19		foreach ($result->getData() as $tuple) {
254	19	View Code Duplication	foreach ($this->space->getFormat() as $index => $info) {
			0 ignored issues – show Duplication introduced 2017-04-06 10:52 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
255			if (array_key_exists($index, $tuple)) {
256			$instance->{$info['name']} = $tuple[$index];
257	19		}
258	19		}
259	4		}
260	19		}
261	19
262			public function truncate()
263			{
264			$this->results = [];
265			$id = $this->space->getId();
266	19		$this->getMapper()->getClient()->evaluate("box.space[$id]:truncate()");
267	19		}
268	1
269	19		public function remove($params = [])
270			{
271			if ($params instanceof Entity) {
272			return $this->removeEntity($params);
273	18		}
274	18
275	18		if (!count($params)) {
276	18		throw new Exception("Use truncate to flush space");
277			}
278
279	18		foreach ($this->find($params) as $entity) {
280	17		$this->removeEntity($entity);
281	17		}
282	17		}
283	1
284	1		public function removeEntity(Entity $instance)
285	1		{
286	1		$key = $this->space->getInstanceKey($instance);
287
288	18		if (!array_key_exists($key, $this->original)) {
289			return;
290			}
291
292	64		if (array_key_exists($key, $this->persisted)) {
293			unset($this->persisted[$key]);
294	64
295			$pk = [];
296		View Code Duplication	foreach ($this->space->getPrimaryIndex()['parts'] as $part) {
			0 ignored issues – show Duplication introduced 2017-04-06 10:52 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
297	64		$pk[] = $this->original[$key][$part[0]];
298			}
299	64
300	64		foreach ($this->getMapper()->getPlugins() as $plugin) {
301			$plugin->beforeRemove($instance, $this->space);
302	64		}
303	64
304			if (method_exists($instance, 'beforeRemove')) {
305			$instance->beforeRemove();
			0 ignored issues – show Documentation Bug introduced 2017-08-13 10:47 UTC by Report Bug Copy Issue Report The method `beforeRemove` does not exist on `object<Tarantool\Mapper\Entity>`? Since you implemented `__call`, maybe consider adding a @method annotation. If you implement `__call` and you know which methods are available, you can improve IDE auto-completion and static analysis by adding a @method annotation to the class. This is often the case, when `__call` is implemented by a parent class and only the child class knows which methods exist: class ParentClass { private $data = array(); public function __call($method, array $args) { if (0 === strpos($method, 'get')) { return $this->data[strtolower(substr($method, 3))]; } throw new \LogicException(sprintf('Unsupported method: %s', $method)); } } /** * If this class knows which fields exist, you can specify the methods here: * * @method string getName() */ class SomeClass extends ParentClass { } Loading history...
306	64		}
307	64
308			$this->getMapper()->getClient()
309			->getSpace($this->space->getId())
310	64		->delete($pk);
311
312			foreach ($this->getMapper()->getPlugins() as $plugin) {
313	64		$plugin->afterRemove($instance, $this->space);
314			}
315	64
316	64		if (method_exists($instance, 'afterRemove')) {
317	64		$instance->afterRemove();
			0 ignored issues – show Documentation Bug introduced 2017-12-14 17:00 UTC by Report Bug Copy Issue Report The method `afterRemove` does not exist on `object<Tarantool\Mapper\Entity>`? Since you implemented `__call`, maybe consider adding a @method annotation. If you implement `__call` and you know which methods are available, you can improve IDE auto-completion and static analysis by adding a @method annotation to the class. This is often the case, when `__call` is implemented by a parent class and only the child class knows which methods exist: class ParentClass { private $data = array(); public function __call($method, array $args) { if (0 === strpos($method, 'get')) { return $this->data[strtolower(substr($method, 3))]; } throw new \LogicException(sprintf('Unsupported method: %s', $method)); } } /** * If this class knows which fields exist, you can specify the methods here: * * @method string getName() */ class SomeClass extends ParentClass { } Loading history...
318			}
319	64		}
320	64
321	64		unset($this->original[$key]);
322	64		unset($this->keys[$instance]);
323	64
324			$this->results = [];
325	64		}
326
327			public function save($instance)
328	64		{
329	64		$key = $this->space->getInstanceKey($instance);
330	64		$client = $this->getMapper()->getClient();
331	64
332	64		if (array_key_exists($key, $this->persisted)) {
333			// update
334	64		$tuple = $this->getTuple($instance);
335			$update = [];
336	64
337		View Code Duplication	foreach ($tuple as $i => $v) {
			0 ignored issues – show Duplication introduced 2017-07-24 21:08 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
338	64		if (!array_key_exists($i, $this->original[$key]) \|\| $v !== $this->original[$key][$i]) {
339			$update[$i] = $v;
340			}
341	64		}
342
343	64		if (!count($update)) {
344			return $instance;
345			}
346	3
347			foreach ($this->getMapper()->getPlugins() as $plugin) {
348	3		$plugin->beforeUpdate($instance, $this->space);
349	3		}
350	3
351	2		if (method_exists($instance, 'beforeUpdate')) {
352	2		$instance->beforeUpdate();
353	2		}
354	2
355			$tuple = $this->getTuple($instance);
356			$update = [];
357
358	2	View Code Duplication	foreach ($tuple as $i => $v) {
			0 ignored issues – show Duplication introduced 2017-07-24 21:08 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
359			if (!array_key_exists($i, $this->original[$key]) \|\| $v !== $this->original[$key][$i]) {
360			$update[$i] = $v;
361	3		}
362			}
363
364			if (!count($update)) {
365			return $instance;
366			}
367
368			$operations = [];
369			foreach ($update as $index => $value) {
370			$operations[] = ['=', $index, $value];
371			}
372
373			$pk = [];
374		View Code Duplication	foreach ($this->space->getPrimaryIndex()['parts'] as $part) {
			0 ignored issues – show Duplication introduced 2017-04-06 10:52 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
375			$pk[] = $this->original[$key][$part[0]];
376			}
377
378			$client->getSpace($this->space->getId())->update($pk, $operations);
379			$this->original[$key] = $tuple;
380
381			foreach ($this->getMapper()->getPlugins() as $plugin) {
382			$plugin->afterUpdate($instance, $this->space);
383			}
384
385			if (method_exists($instance, 'afterUpdate')) {
386			$instance->afterUpdate();
387			}
388			} else {
389			$this->addDefaultValues($instance);
390			foreach ($this->getMapper()->getPlugins() as $plugin) {
391			$plugin->beforeCreate($instance, $this->space);
392			}
393
394			if (method_exists($instance, 'beforeCreate')) {
395			$instance->beforeCreate();
396			}
397
398			$tuple = $this->getTuple($instance);
399			$client->getSpace($this->space->getId())->insert($tuple);
400			$this->persisted[$key] = $instance;
401			$this->original[$key] = $tuple;
402
403			foreach ($this->getMapper()->getPlugins() as $plugin) {
404			$plugin->afterCreate($instance, $this->space);
405			}
406
407			if (method_exists($instance, 'afterCreate')) {
408			$instance->afterCreate();
409			}
410			}
411
412			$this->flushCache();
413
414			return $instance;
415			}
416
417			private function addDefaultValues(Entity $instance)
418			{
419			$format = $this->space->getFormat();
420
421			// complete format fields
422			foreach ($format as $info) {
423			$name = $info['name'];
424			if (!property_exists($instance, $name)) {
425			$instance->$name = null;
426			}
427			}
428			}
429
430			public function getOriginal($instance)
431			{
432			return $this->original[$this->space->getInstanceKey($instance)];
433			}
434
435			private function getTuple(Entity $instance)
436			{
437			$schema = $this->getMapper()->getSchema();
438			$tuple = [];
439
440			foreach ($this->space->getFormat() as $index => $info) {
441			$name = $info['name'];
442			if (!property_exists($instance, $name)) {
443			$instance->$name = null;
444			}
445
446			$instance->$name = $schema->formatValue($info['type'], $instance->$name);
447			if (is_null($instance->$name)) {
448			if (!$this->space->isPropertyNullable($name)) {
449			$instance->$name = $schema->getDefaultValue($info['type']);
450			}
451			}
452
453			$tuple[$index] = $instance->$name;
454			}
455
456			return $tuple;
457			}
458
459			public function sync($id, $fields = null)
460			{
461			if (array_key_exists($id, $this->persisted)) {
462			$tuple = $this->getMapper()->getClient()->getSpace($this->space->getId())->select([$id], 0)->getData()[0];
463
464			foreach ($this->space->getFormat() as $index => $info) {
465			if (!$fields \|\| in_array($info['name'], $fields)) {
466			$value = array_key_exists($index, $tuple) ? $tuple[$index] : null;
467			$this->persisted[$id]->{$info['name']} = $value;
468			$this->original[$id][$index] = $value;
469			}
470			}
471			}
472			}
473
474			public function flushCache()
475			{
476			$this->results = [];
477			}
478			}
479

tarantool-php / mapper