Type - Code Metrics - Inspection of "composite index check while property is removed" - tarantool-php/mapper - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 1e32a0...e93ee4 )

by Dmitry

created 2016-04-19 15:30 UTC

Type C

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	359
Duplicated Lines	6.13 %

Coupling/Cohesion

Components	1
Dependencies	6

Test Coverage

Coverage

98.31%

Importance

Changes	38
Bugs	6	Features	10

Metric	Value
wmc	73
c	38
b	6
f	10
lcom	1
cbo	6
dl	22
loc	359
ccs	174
cts	177
cp	0.9831
rs	5.5447

27 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	11	1
A	getSpace()	0	8	2
A	getSpaceId()	0	4	1
A	getManager()	0	4	1
A	getName()	0	4	1
A	hasProperty()	0	4	1
A	getProperties()	0	4	1
A	getPropertyType()	0	4	1
C	addIndex()	0	34	8
A	setPropertyType()	0	22	3
A	addProperty()	0	20	3
C	removeProperty()	0	30	7
A	reference()	0	12	2
A	isReference()	0	4	1
B	getReferenceProperty()	0	17	5
A	getReferences()	0	12	3
A	getRequiredProperties()	0	15	4
A	getIndex()	0	4	1
A	dropIndex()	0	3	1
A	getIndexes()	0	4	1
B	findIndex()	0	25	6
A	getIndexTuple()	0	11	3
C	getCompleteTuple()	0	29	8
A	getTuple()	11	11	3
A	fromTuple()	11	11	3
A	encodeProperty()	0	4	1
A	decodeProperty()	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 Type 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 Type, and based on these observations, apply Extract Interface, too.

<?php

namespace Tarantool\Mapper\Schema;

use Tarantool\Mapper\Contracts;
use LogicException;

class Type implements Contracts\Type
{
    private $convention;
    private $properties = [];
    private $indexes = [];
    private $types = [];

    private $manager;
    private $space;
    private $spaceId;
    private $name;

    public function __construct(Contracts\Manager $manager, $name, array $properties, array $types, array $indexes)
    {
        $this->manager = $manager;
        $this->name = $name;
        $this->convention = $manager->getMeta()->getConvention();
        $this->spaceId = $manager->getSchema()->getSpaceId($name);

        $this->properties = $properties;
        $this->indexes = $indexes;
        $this->types = $types;
    }

    public function getSpace()
    {
        if (!$this->space) {
            $this->space = $this->getManager()->getClient()->getSpace($this->spaceId);
        }

        return $this->space;
    }

    public function getSpaceId()
    {
        return $this->spaceId;
    }

    public function getManager()
    {
        return $this->manager;
    }

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

    public function addIndex($properties, array $arguments = null)
    {
        $properties = (array) $properties;
        foreach ($properties as $property) {
            if (!$this->hasProperty($property)) {
                throw new LogicException("Unknown property $property for ".$this->name);
            }
        }

        $schema = $this->manager->getSchema();

        $indexName = implode('_', $properties);

        if ($schema->hasIndex($this->getName(), $indexName)) {
            throw new LogicException("Index $indexName already exists!");
        }

        if (!$arguments) {
            $arguments = [];
        }

        if (!array_key_exists('parts', $arguments) || !count($arguments['parts'])) {
            $arguments['parts'] = [];
            foreach ($properties as $property) {
                $arguments['parts'][] = array_search($property, $this->properties) + 1;
                $arguments['parts'][] = $this->convention->getTarantoolType($this->types[$property]);
            }
        }

        $num = $schema->createIndex($this->getName(), $indexName, $arguments);
        $this->indexes[$num] = $properties;

        return $this;
    }

    /**
     * @param $property name
     *
     * @return Type
     */
    public function addProperty($name, $type = null)
    {
        if ($this->hasProperty($name)) {
            throw new LogicException("Duplicate property $name");
        }
        if (!$type) {
            $type = $this->manager->getMeta()->getConvention()->getType($name);
        }
        $this->types[$name] = $type;
        $property = $this->manager->create('property', [
            'space' => $this->spaceId,
            'index' => count($this->properties),
            'name' => $name,
            'type' => $this->types[$name],
        ]);

        $this->properties[$property->index] = $name;
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}

        return $this;
    }

    public function hasProperty($name)
    {
        return in_array($name, $this->properties);
    }

    public function getProperties()
    {
        return $this->properties;
    }

    public function getPropertyType($property)
    {
        return $this->types[$property];
    }

    public function setPropertyType($property, $type)
    {
        if (is_array($property)) {
            foreach ($property as $prop) {
                $this->setPropertyType($prop, $type);
            }

            return $this;
        }

        $this->types[$property] = $type;

        // update entity
        $row = $this->getManager()->get('property')->findOne([
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.
}
            'space' => $this->spaceId,
            'index' => array_search($property, $this->properties),
        ]);
        $row->type = $type;
        $this->getManager()->save($row);

        return $this;
    }

    public function removeProperty($name)
    {
        if (!$this->hasProperty($name)) {
            throw new LogicException("Unknown property $name");
        }

        foreach ($this->indexes as $index => $fields) {
            if ($fields != [$name] && in_array($name, $fields)) {
                throw new LogicException("Property is used by composite index $index");
            }
        }

        foreach ($this->indexes as $index => $fields) {
            if ($fields == [$name]) {
                unset($this->indexes[$index]);
            }
        }

        $index = array_search($name, $this->properties);

        unset($this->properties[$index]);
        unset($this->types[$name]);

        $property = $this->manager->get('property')->findOne([
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.
}
            'space' => $this->spaceId,
            'index' => $index,
        ]);

        $this->manager->remove($property);
    }

    public function reference(Contracts\Type $foreign, $property = null)
    {
        if (!$property) {
            $property = $foreign->getName();
        }

        $this->addProperty($property);
        $this->setPropertyType($property, $foreign->getName());
        $this->addIndex($property, ['unique' => false]);

        return $this;
    }

    public function isReference($property)
    {
        return !$this->convention->isPrimitive($this->types[$property]);
    }

    public function getReferenceProperty(Contracts\Type $type)
    {
        $properties = [];
        foreach ($this->types as $property => $propertyType) {
            if ($type->getName() == $propertyType) {
                $properties[] = $property;
            }
        }
        if (!count($properties)) {
            throw new LogicException('Type '.$this->getName().' is not related with '.$type->getName());
        }
        if (count($properties) > 1) {
            throw new LogicException('Multiple type reference found');
        }

        return $properties[0];
    }

    public function getReferences()
    {
        $references = [];
        $convention = $this->manager->getMeta()->getConvention();
        foreach ($this->types as $property => $type) {
            if (!$convention->isPrimitive($type)) {
                $references[$property] = $type;
            }
        }

        return $references;
    }

    public function getRequiredProperties()
    {
        if (!isset($this->requiredProperties)) {
            $this->requiredProperties = ['id' => 1];

            $indexList = $this->manager->getSchema()->listIndexes($this->getName());
            foreach ($indexList as $name => $fields) {
                foreach ($fields as $num) {
                    $this->requiredProperties[$this->properties[$num]] = true;

                }
            }
            $this->requiredProperties = array_keys($this->requiredProperties);

        }

        return $this->requiredProperties;

    }

    public function getIndex($num)
    {
        return $this->indexes[$num];
    }

    public function dropIndex($num)
    {
    }

    public function getIndexes()
    {
        return $this->indexes;
    }

    public function findIndex($query)
    {
        if (!count($query)) {
            return 0;
        }

        sort($query);
        foreach ($this->indexes as $name => $fields) {
            if ($fields == $query) {
                return $name;
            }
        }

        // cast partial index
        $casting = [];

        foreach ($this->indexes as $name => $fields) {
            if (!count(array_diff($query, $fields))) {
                $casting[count(array_diff($fields, $query))] = $name;
            }
        }
        ksort($casting);

        return array_shift($casting);
    }

    public function getIndexTuple($index, $params)
    {
        $tuple = [];
        foreach ($this->indexes[$index] as $property) {
            if (array_key_exists($property, $params)) {
                $tuple[array_search($property, $this->indexes[$index])] = $params[$property];
            }
        }

        return $tuple;
    }

    public function getCompleteTuple($input)
    {
        $tuple = $this->getTuple($input);
        $required = $this->getRequiredProperties();

        foreach ($this->getProperties() as $index => $field) {
            if (in_array($field, $required) && !array_key_exists($index, $tuple)) {
                if ($this->isReference($field)) {
                    $tuple[$index] = 0;
                } else {
                    $tuple[$index] = '';
                }
            }
        }

        // normalize tuple
        if (array_values($tuple) != $tuple) {
            // index was skipped
            $max = max(array_keys($tuple));
            foreach (range(0, $max) as $index) {
                if (!array_key_exists($index, $tuple)) {
                    $tuple[$index] = null;
                }
            }
            ksort($tuple);
        }

        return $tuple;
    }

    public function getTuple($input)

    {
        $output = [];
        foreach ($this->getProperties() as $index => $name) {
            if (array_key_exists($name, $input)) {
                $output[$index] = $this->encodeProperty($name, $input[$name]);
            }
        }

        return $output;
    }

    public function fromTuple($input)

    {
        $output = [];
        foreach ($this->getProperties() as $index => $name) {
            if (array_key_exists($index, $input)) {
                $output[$name] = $this->decodeProperty($name, $input[$index]);
            }
        }

        return $output;
    }

    public function encodeProperty($name, $value)
    {
        return $this->convention->encode($this->types[$name], $value);
    }

    public function decodeProperty($name, $value)
    {
        return $this->convention->decode($this->types[$name], $value);
    }
}


Push — master ( 1e32a0...e93ee4 )

Type C

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

27 Methods

How to fix Duplicated Code Complexity

Duplicated Code

Complex Class

Available Fixes

Available Fixes

Available Fixes

1			<?php
2
3			namespace Tarantool\Mapper\Schema;
4
5			use Tarantool\Mapper\Contracts;
6			use LogicException;
7
8			class Type implements Contracts\Type
9			{
10			private $convention;
11			private $properties = [];
12			private $indexes = [];
13			private $types = [];
14
15			private $manager;
16			private $space;
17			private $spaceId;
18			private $name;
19
20	39		public function __construct(Contracts\Manager $manager, $name, array $properties, array $types, array $indexes)
21			{
22	39		$this->manager = $manager;
23	39		$this->name = $name;
24	39		$this->convention = $manager->getMeta()->getConvention();
25	39		$this->spaceId = $manager->getSchema()->getSpaceId($name);
26
27	39		$this->properties = $properties;
28	39		$this->indexes = $indexes;
29	39		$this->types = $types;
30	39		}
31
32	39		public function getSpace()
33			{
34	39		if (!$this->space) {
35	39		$this->space = $this->getManager()->getClient()->getSpace($this->spaceId);
36			}
37
38	39		return $this->space;
39			}
40
41	39		public function getSpaceId()
42			{
43	39		return $this->spaceId;
44			}
45
46	39		public function getManager()
47			{
48	39		return $this->manager;
49			}
50
51	39		public function getName()
52			{
53	39		return $this->name;
54			}
55
56	39		public function addIndex($properties, array $arguments = null)
57			{
58	39		$properties = (array) $properties;
59	39		foreach ($properties as $property) {
60	39		if (!$this->hasProperty($property)) {
61	39		throw new LogicException("Unknown property $property for ".$this->name);
62			}
63			}
64
65	39		$schema = $this->manager->getSchema();
66
67	39		$indexName = implode('_', $properties);
68
69	39		if ($schema->hasIndex($this->getName(), $indexName)) {
70	1		throw new LogicException("Index $indexName already exists!");
71			}
72
73	39		if (!$arguments) {
74	39		$arguments = [];
75			}
76
77	39		if (!array_key_exists('parts', $arguments) \|\| !count($arguments['parts'])) {
78	39		$arguments['parts'] = [];
79	39		foreach ($properties as $property) {
80	39		$arguments['parts'][] = array_search($property, $this->properties) + 1;
81	39		$arguments['parts'][] = $this->convention->getTarantoolType($this->types[$property]);
82			}
83			}
84
85	39		$num = $schema->createIndex($this->getName(), $indexName, $arguments);
86	39		$this->indexes[$num] = $properties;
87
88	39		return $this;
89			}
90
91			/**
92			* @param $property name
93			*
94			* @return Type
95			*/
96	39		public function addProperty($name, $type = null)
97			{
98	39		if ($this->hasProperty($name)) {
99	1		throw new LogicException("Duplicate property $name");
100			}
101	39		if (!$type) {
102	39		$type = $this->manager->getMeta()->getConvention()->getType($name);
103			}
104	39		$this->types[$name] = $type;
105	39		$property = $this->manager->create('property', [
106	39		'space' => $this->spaceId,
107	39		'index' => count($this->properties),
108	39		'name' => $name,
109	39		'type' => $this->types[$name],
110			]);
111
112	39		$this->properties[$property->index] = $name;
			0 ignored issues – show Bug introduced 2016-04-19 11:11 UTC by Report Bug Copy Issue Report Accessing `index` on the interface `Tarantool\Mapper\Contracts\Entity` suggest that you code against a concrete implementation. How about adding an `instanceof` check? If you access a property on an interface, you most likely code against a concrete implementation of the interface. Available Fixes Adding an additional type check: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeInterface $object) { if ($object instanceof SomeClass) { $a = $object->a; } } Changing the type hint: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeClass $object) { $a = $object->a; } Loading history...
113
114	39		return $this;
115			}
116
117	39		public function hasProperty($name)
118			{
119	39		return in_array($name, $this->properties);
120			}
121
122	39		public function getProperties()
123			{
124	39		return $this->properties;
125			}
126
127	2		public function getPropertyType($property)
128			{
129	2		return $this->types[$property];
130			}
131
132	7		public function setPropertyType($property, $type)
133			{
134	7		if (is_array($property)) {
135	1		foreach ($property as $prop) {
136	1		$this->setPropertyType($prop, $type);
137			}
138
139	1		return $this;
140			}
141
142	7		$this->types[$property] = $type;
143
144			// update entity
145	7		$row = $this->getManager()->get('property')->findOne([
			0 ignored issues – show Bug introduced 2016-04-04 18:16 UTC by Report Bug Copy Issue Report The method `findOne` 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...
146	7		'space' => $this->spaceId,
147	7		'index' => array_search($property, $this->properties),
148			]);
149	7		$row->type = $type;
150	7		$this->getManager()->save($row);
151
152	7		return $this;
153			}
154
155	4		public function removeProperty($name)
156			{
157	4		if (!$this->hasProperty($name)) {
158			throw new LogicException("Unknown property $name");
159			}
160
161	4		foreach ($this->indexes as $index => $fields) {
162	4		if ($fields != [$name] && in_array($name, $fields)) {
163	4		throw new LogicException("Property is used by composite index $index");
164			}
165			}
166
167	3		foreach ($this->indexes as $index => $fields) {
168	3		if ($fields == [$name]) {
169	3		unset($this->indexes[$index]);
170			}
171			}
172
173	3		$index = array_search($name, $this->properties);
174
175	3		unset($this->properties[$index]);
176	3		unset($this->types[$name]);
177
178	3		$property = $this->manager->get('property')->findOne([
			0 ignored issues – show Bug introduced 2016-04-17 17:00 UTC by Report Bug Copy Issue Report The method `findOne` 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...
179	3		'space' => $this->spaceId,
180	3		'index' => $index,
181			]);
182
183	3		$this->manager->remove($property);
184	3		}
185
186	5		public function reference(Contracts\Type $foreign, $property = null)
187			{
188	5		if (!$property) {
189	4		$property = $foreign->getName();
190			}
191
192	5		$this->addProperty($property);
193	5		$this->setPropertyType($property, $foreign->getName());
194	5		$this->addIndex($property, ['unique' => false]);
195
196	5		return $this;
197			}
198
199	39		public function isReference($property)
200			{
201	39		return !$this->convention->isPrimitive($this->types[$property]);
202			}
203
204	4		public function getReferenceProperty(Contracts\Type $type)
205			{
206	4		$properties = [];
207	4		foreach ($this->types as $property => $propertyType) {
208	4		if ($type->getName() == $propertyType) {
209	4		$properties[] = $property;
210			}
211			}
212	4		if (!count($properties)) {
213	1		throw new LogicException('Type '.$this->getName().' is not related with '.$type->getName());
214			}
215	3		if (count($properties) > 1) {
216	1		throw new LogicException('Multiple type reference found');
217			}
218
219	2		return $properties[0];
220			}
221
222	1		public function getReferences()
223			{
224	1		$references = [];
225	1		$convention = $this->manager->getMeta()->getConvention();
226	1		foreach ($this->types as $property => $type) {
227	1		if (!$convention->isPrimitive($type)) {
228	1		$references[$property] = $type;
229			}
230			}
231
232	1		return $references;
233			}
234
235	39		public function getRequiredProperties()
236			{
237	39		if (!isset($this->requiredProperties)) {
238	39		$this->requiredProperties = ['id' => 1];
			0 ignored issues – show Bug introduced 2016-04-04 18:16 UTC by Report Bug Copy Issue Report The property `requiredProperties` does not seem to exist. Did you mean `properties`? An attempt at access to an undefined property has been detected. This may either be a typographical error or the property has been renamed but there are still references to its old name. If you really want to allow access to undefined properties, you can define magic methods to allow access. See the php core documentation on Overloading. Loading history...
239	39		$indexList = $this->manager->getSchema()->listIndexes($this->getName());
240	39		foreach ($indexList as $name => $fields) {
241	39		foreach ($fields as $num) {
242	39		$this->requiredProperties[$this->properties[$num]] = true;
			0 ignored issues – show Bug introduced 2016-04-04 18:16 UTC by Report Bug Copy Issue Report The property `requiredProperties` does not seem to exist. Did you mean `properties`? An attempt at access to an undefined property has been detected. This may either be a typographical error or the property has been renamed but there are still references to its old name. If you really want to allow access to undefined properties, you can define magic methods to allow access. See the php core documentation on Overloading. Loading history...
243			}
244			}
245	39		$this->requiredProperties = array_keys($this->requiredProperties);
			0 ignored issues – show Bug introduced 2016-04-04 18:16 UTC by Report Bug Copy Issue Report The property `requiredProperties` does not seem to exist. Did you mean `properties`? An attempt at access to an undefined property has been detected. This may either be a typographical error or the property has been renamed but there are still references to its old name. If you really want to allow access to undefined properties, you can define magic methods to allow access. See the php core documentation on Overloading. Loading history...
246			}
247
248	39		return $this->requiredProperties;
			0 ignored issues – show Bug introduced 2016-04-04 18:16 UTC by Report Bug Copy Issue Report The property `requiredProperties` does not seem to exist. Did you mean `properties`? An attempt at access to an undefined property has been detected. This may either be a typographical error or the property has been renamed but there are still references to its old name. If you really want to allow access to undefined properties, you can define magic methods to allow access. See the php core documentation on Overloading. Loading history...
249			}
250
251	1		public function getIndex($num)
252			{
253	1		return $this->indexes[$num];
254			}
255
256			public function dropIndex($num)
257			{
258			}
259
260	2		public function getIndexes()
261			{
262	2		return $this->indexes;
263			}
264
265	39		public function findIndex($query)
266			{
267	39		if (!count($query)) {
268	3		return 0;
269			}
270
271	39		sort($query);
272	39		foreach ($this->indexes as $name => $fields) {
273	39		if ($fields == $query) {
274	39		return $name;
275			}
276			}
277
278			// cast partial index
279	3		$casting = [];
280
281	3		foreach ($this->indexes as $name => $fields) {
282	3		if (!count(array_diff($query, $fields))) {
283	3		$casting[count(array_diff($fields, $query))] = $name;
284			}
285			}
286	3		ksort($casting);
287
288	3		return array_shift($casting);
289			}
290
291	39		public function getIndexTuple($index, $params)
292			{
293	39		$tuple = [];
294	39		foreach ($this->indexes[$index] as $property) {
295	39		if (array_key_exists($property, $params)) {
296	39		$tuple[array_search($property, $this->indexes[$index])] = $params[$property];
297			}
298			}
299
300	39		return $tuple;
301			}
302
303	39		public function getCompleteTuple($input)
304			{
305	39		$tuple = $this->getTuple($input);
306	39		$required = $this->getRequiredProperties();
307
308	39		foreach ($this->getProperties() as $index => $field) {
309	39		if (in_array($field, $required) && !array_key_exists($index, $tuple)) {
310	1		if ($this->isReference($field)) {
311	1		$tuple[$index] = 0;
312			} else {
313	39		$tuple[$index] = '';
314			}
315			}
316			}
317
318			// normalize tuple
319	39		if (array_values($tuple) != $tuple) {
320			// index was skipped
321	3		$max = max(array_keys($tuple));
322	3		foreach (range(0, $max) as $index) {
323	3		if (!array_key_exists($index, $tuple)) {
324	3		$tuple[$index] = null;
325			}
326			}
327	3		ksort($tuple);
328			}
329
330	39		return $tuple;
331			}
332
333	39	View Code Duplication	public function getTuple($input)
			0 ignored issues – show Duplication introduced 2016-04-10 11:30 UTC by Report Bug Copy Issue Report This method seems to be duplicated in 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...
334			{
335	39		$output = [];
336	39		foreach ($this->getProperties() as $index => $name) {
337	39		if (array_key_exists($name, $input)) {
338	39		$output[$index] = $this->encodeProperty($name, $input[$name]);
339			}
340			}
341
342	39		return $output;
343			}
344
345	39	View Code Duplication	public function fromTuple($input)
			0 ignored issues – show Duplication introduced 2016-04-10 11:30 UTC by Report Bug Copy Issue Report This method seems to be duplicated in 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...
346			{
347	39		$output = [];
348	39		foreach ($this->getProperties() as $index => $name) {
349	39		if (array_key_exists($index, $input)) {
350	39		$output[$name] = $this->decodeProperty($name, $input[$index]);
351			}
352			}
353
354	39		return $output;
355			}
356
357	39		public function encodeProperty($name, $value)
358			{
359	39		return $this->convention->encode($this->types[$name], $value);
360			}
361
362	39		public function decodeProperty($name, $value)
363			{
364	39		return $this->convention->decode($this->types[$name], $value);
365			}
366			}
367

tarantool-php / mapper

Push — master ( 1e32a0...e93ee4 )

Type C

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

27 Methods

How to fix Duplicated Code Complexity

Duplicated Code

Complex Class

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like