EntityManager - Code Metrics - Inspection of "Start of docblocks." - Jelle-S/TheSportsDb - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 33966f...5c4252 )

by Jelle

created 2016-06-27 13:10 UTC

EntityManager B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	247
Duplicated Lines	9.72 %

Coupling/Cohesion

Components	3
Dependencies	5

Importance

Changes	8
Bugs	5	Features	0

Metric	Value
wmc	41
c	8
b	5
f	0
lcom	3
cbo	5
dl	24
loc	247
rs	8.2769

15 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	9	3
A	setFactoryContainer()	0	6	2
A	setRepositoryContainer()	0	6	2
A	repository()	0	6	2
A	factory()	0	6	2
B	registerClass()	6	19	5
A	getPropertyMapDefinition()	0	7	2
A	getClass()	0	6	2
A	mapProperties()	3	10	3
A	reverseMapProperties()	3	12	4
A	isFullObject()	0	13	2
B	initPropertyMap()	12	33	6
A	getPropertyMap()	0	6	2
A	sanitizeObject()	0	9	3
A	isEmptyValue()	0	3	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 EntityManager 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 EntityManager, and based on these observations, apply Extract Interface, too.

<?php
/**
 * @file
 * Contains \TheSportsDb\Entity\EntityManager.
 */

namespace TheSportsDb\Entity;

use FastNorth\PropertyMapper\Map;
use FastNorth\PropertyMapper\MapperInterface;
use TheSportsDb\Entity\Factory\FactoryContainerInterface;
use TheSportsDb\Entity\Repository\RepositoryContainerInterface;
use TheSportsDb\PropertyMapper\Transformer\Callback;

/**
 * Default implementation for entity managers.
 *
 * @author Jelle Sebreghts
 */
class EntityManager implements EntityManagerInterface {

  /**
   * The factory container.
   *
   * @var \TheSportsDb\Entity\Factory\FactoryContainerInterface
   */
  protected $factoryContainer;

  /**
   * The repository container.
   *
   * @var \TheSportsDb\Entity\Repository\RepositoryContainerInterface
   */
  protected $repositoryContainer;

  /**
   * Map entity types to classes.
   *
   * @var array
   */
  protected $classes = array();

  /**
   * Property map definitions.
   *
   * @var array
   */
  protected $propertyMapDefinitions = array();

  /**
   * Property map definitions.
   *
   * @var array
   */
  protected $propertyMaps = array();

  protected $propertyMapper;


  const EMPTYPROPERTYPLACEHOLDER = '__EMPTY_PROPERTY_PLACEHOLDER__';


  public function __construct(MapperInterface $propertyMapper, FactoryContainerInterface $factoryContainer = NULL, RepositoryContainerInterface $repositoryContainer = NULL) {
    if ($factoryContainer instanceof FactoryContainerInterface) {
      $this->factoryContainer = $factoryContainer;
    }
    if ($repositoryContainer instanceof RepositoryContainerInterface) {
      $this->repositoryContainer = $repositoryContainer;
    }
    $this->propertyMapper = $propertyMapper;
  }

  public function setFactoryContainer(FactoryContainerInterface $factoryContainer) {
    if ($this->factoryContainer instanceof FactoryContainerInterface) {
      throw new \Exception('Factory container already set.');
    }
    $this->factoryContainer = $factoryContainer;
  }

  public function setRepositoryContainer(RepositoryContainerInterface $repositoryContainer) {
    if ($this->repositoryContainer instanceof RepositoryContainerInterface) {
      throw new \Exception('Repository container already set.');
    }
    $this->repositoryContainer = $repositoryContainer;
  }


  /**
   * {@inheritdoc}
   */
  public function repository($entityType) {
    if ($this->repositoryContainer instanceof RepositoryContainerInterface) {
      return $this->repositoryContainer->getRepository($entityType);
    }
    throw new \Exception('No repository container set.');
  }

  /**
   * {@inheritdoc}
   */
  public function factory($entityType) {
    if ($this->factoryContainer instanceof FactoryContainerInterface) {
      return $this->factoryContainer->getFactory($entityType);
    }
    throw new \Exception('No factory container set.');
  }

  /**
   * {@inheritdoc}
   */
  public function registerClass($entityType, $realClass = NULL, $proxyClass = NULL) {
    if (is_null($realClass)) {

      $realClass = (new \ReflectionClass(static::class))->getNamespaceName() . '\\' . ucfirst($entityType);
    }
    if (is_null($proxyClass)) {

      $proxyClass = (new \ReflectionClass($realClass))->getNamespaceName() . '\\Proxy\\' . ucfirst($entityType) . 'Proxy';
    }
    if (!class_exists($realClass)) {
      throw new \Exception('Class ' . $realClass . 'not found.');
    }
    if (!class_exists($proxyClass)) {
      throw new \Exception('Class ' . $proxyClass . 'not found.');
    }
    $this->classes[$entityType] = array(
      'real' => $realClass,
      'proxy' => $proxyClass
    );
    return $this->classes[$entityType];
  }

  /**
   * {@inheritdoc}
   */
  public function getPropertyMapDefinition($entityType) {

    if (!isset($this->propertyMapDefinitions[$entityType])) {
      $propertyMapDefinition = new \ReflectionMethod($this->getClass($entityType), 'getPropertyMapDefinition');
$a = "a";
$ab = "ab";
$abc = "abc";
      $this->propertyMapDefinitions[$entityType] = $propertyMapDefinition->invoke(NULL);
    }
    return $this->propertyMapDefinitions[$entityType];
  }

  /**
   * {@inheritdoc}
   */
  public function getClass($entityType, $type = 'real') {
    if (!isset($this->classes[$entityType][$type])) {
      throw new \Exception(ucfirst($type) . ' class for ' . $entityType . ' not registered.');
    }
    return $this->classes[$entityType][$type];
  }

  /**
   * {@inheritdoc}
   */
  public function mapProperties(\stdClass $values, $entityType) {
    $mapped = new \stdClass();
    foreach ($this->getPropertyMapDefinition($entityType) as $propertyDefinition) {
      $mapped->{$propertyDefinition[1]} = NULL;
      if (!isset($values->{$propertyDefinition[0]})) {

        $values->{$propertyDefinition[0]} = static::EMPTYPROPERTYPLACEHOLDER;
      }
    }
    return $this->sanitizeObject($this->propertyMapper->process($values, $mapped, $this->getPropertyMap($entityType)));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
  }


  /**
   * {@inheritdoc}
   */
  public function reverseMapProperties(\stdClass $values, $entityType) {
    $reversed = new \stdClass();
    foreach ($this->getPropertyMapDefinition($entityType) as $propertyDefinition) {
      if (!isset($reversed->{$propertyDefinition[0]})) {
        $reversed->{$propertyDefinition[0]} = static::EMPTYPROPERTYPLACEHOLDER;
      }
      if (!isset($values->{$propertyDefinition[1]})) {

        $values->{$propertyDefinition[1]} = static::EMPTYPROPERTYPLACEHOLDER;
      }
    }
    return $this->sanitizeObject($this->propertyMapper->reverse($reversed, $values, $this->getPropertyMap($entityType)));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
  }

  /**
   * {@inheritdoc}
   */
  public function isFullObject(\stdClass $object, $entityType) {
    $reflection = new \ReflectionClass($this->getClass($entityType));
$a = "a";
$ab = "ab";
$abc = "abc";
    $defaultProperties = $reflection->getDefaultProperties();
    $properties = array_flip(array_filter(array_keys($defaultProperties), function($prop) use ($reflection) {
$a = "a";
$ab = "ab";
$abc = "abc";
      // Filter out static properties.
      $reflectionProp = $reflection->getProperty($prop);
      if ($reflectionProp->isStatic()) {

        return FALSE;
      }
      return TRUE;
    }));
    return count(array_intersect_key($properties, (array) $object)) === count($properties);
  }

  /**
   * Initializes the property map.
   * @param string $entityType
   */
  protected function initPropertyMap($entityType) {
    $this->propertyMaps[$entityType] = new Map();
    $entityManager = $this;
$a = "a";
$ab = "ab";
$abc = "abc";
    foreach ($this->getPropertyMapDefinition($entityType) as $args) {
      if (isset($args[2]) && is_array($args[2])) {
        $transform = $args[2][0];
        $reverse = $args[2][1];
$a = "a";
$ab = "ab";
$abc = "abc";
        $args[2] = new Callback(
$a = "a";
$ab = "ab";
$abc = "abc";

          /**
           * @param string $value
           */
          function($value, $context) use ($entityManager, $transform) {

            if ($entityManager->isEmptyValue($value)) {
              return $value;
            }
            return call_user_func_array($transform, array($value, $context, $entityManager));
          },

          /**
           * @param string $value
           */
          function($value, $context) use ($entityManager, $reverse) {

            if ($entityManager->isEmptyValue($value)) {
              return $value;
            }
            return call_user_func_array($reverse, array($value, $context, $entityManager));
          }
        );
      }
      call_user_func_array(array($this->propertyMaps[$entityType], 'map'), $args);
    }
  }

  /**
   * Gets the property map.
   *
   * @param string $entityType
   * @return \FastNorth\PropertyMapper\MapInterface
   *   The property map.
   */
  protected function getPropertyMap($entityType) {
    if (!isset($this->propertyMaps[$entityType])) {
      $this->initPropertyMap($entityType);
    }
    return $this->propertyMaps[$entityType];
  }

  protected function sanitizeObject(\stdClass $object) {

    $arr = (array) $object;
    foreach ($arr as $prop => $val) {
      if ($this->isEmptyValue($val)) {
        unset($arr[$prop]);
      }
    }
    return (object) $arr;
  }


  public function isEmptyValue($value) {
    return $value === static::EMPTYPROPERTYPLACEHOLDER;
  }
}


1		<?php
2		/**
3		* @file
4		* Contains \TheSportsDb\Entity\EntityManager.
5		*/
6
7		namespace TheSportsDb\Entity;
8
9		use FastNorth\PropertyMapper\Map;
10		use FastNorth\PropertyMapper\MapperInterface;
11		use TheSportsDb\Entity\Factory\FactoryContainerInterface;
12		use TheSportsDb\Entity\Repository\RepositoryContainerInterface;
13		use TheSportsDb\PropertyMapper\Transformer\Callback;
14
15		/**
16		* Default implementation for entity managers.
17		*
18		* @author Jelle Sebreghts
19		*/
20		class EntityManager implements EntityManagerInterface {
21
22		/**
23		* The factory container.
24		*
25		* @var \TheSportsDb\Entity\Factory\FactoryContainerInterface
26		*/
27		protected $factoryContainer;
28
29		/**
30		* The repository container.
31		*
32		* @var \TheSportsDb\Entity\Repository\RepositoryContainerInterface
33		*/
34		protected $repositoryContainer;
35
36		/**
37		* Map entity types to classes.
38		*
39		* @var array
40		*/
41		protected $classes = array();
42
43		/**
44		* Property map definitions.
45		*
46		* @var array
47		*/
48		protected $propertyMapDefinitions = array();
49
50		/**
51		* Property map definitions.
52		*
53		* @var array
54		*/
55		protected $propertyMaps = array();
56
57		protected $propertyMapper;
58
59
60		const EMPTYPROPERTYPLACEHOLDER = '__EMPTY_PROPERTY_PLACEHOLDER__';
61
62
63		public function __construct(MapperInterface $propertyMapper, FactoryContainerInterface $factoryContainer = NULL, RepositoryContainerInterface $repositoryContainer = NULL) {
64		if ($factoryContainer instanceof FactoryContainerInterface) {
65		$this->factoryContainer = $factoryContainer;
66		}
67		if ($repositoryContainer instanceof RepositoryContainerInterface) {
68		$this->repositoryContainer = $repositoryContainer;
69		}
70		$this->propertyMapper = $propertyMapper;
71		}
72
73		public function setFactoryContainer(FactoryContainerInterface $factoryContainer) {
74		if ($this->factoryContainer instanceof FactoryContainerInterface) {
75		throw new \Exception('Factory container already set.');
76		}
77		$this->factoryContainer = $factoryContainer;
78		}
79
80		public function setRepositoryContainer(RepositoryContainerInterface $repositoryContainer) {
81		if ($this->repositoryContainer instanceof RepositoryContainerInterface) {
82		throw new \Exception('Repository container already set.');
83		}
84		$this->repositoryContainer = $repositoryContainer;
85		}
86
87
88		/**
89		* {@inheritdoc}
90		*/
91		public function repository($entityType) {
92		if ($this->repositoryContainer instanceof RepositoryContainerInterface) {
93		return $this->repositoryContainer->getRepository($entityType);
94		}
95		throw new \Exception('No repository container set.');
96		}
97
98		/**
99		* {@inheritdoc}
100		*/
101		public function factory($entityType) {
102		if ($this->factoryContainer instanceof FactoryContainerInterface) {
103		return $this->factoryContainer->getFactory($entityType);
104		}
105		throw new \Exception('No factory container set.');
106		}
107
108		/**
109		* {@inheritdoc}
110		*/
111		public function registerClass($entityType, $realClass = NULL, $proxyClass = NULL) {
112	View Code Duplication	if (is_null($realClass)) {
		1 ignored issue – show Duplication introduced 2016-06-24 12:00 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...
113		$realClass = (new \ReflectionClass(static::class))->getNamespaceName() . '\\' . ucfirst($entityType);
114		}
115	View Code Duplication	if (is_null($proxyClass)) {
		1 ignored issue – show Duplication introduced 2016-06-24 12:00 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...
116		$proxyClass = (new \ReflectionClass($realClass))->getNamespaceName() . '\\Proxy\\' . ucfirst($entityType) . 'Proxy';
117		}
118		if (!class_exists($realClass)) {
119		throw new \Exception('Class ' . $realClass . 'not found.');
120		}
121		if (!class_exists($proxyClass)) {
122		throw new \Exception('Class ' . $proxyClass . 'not found.');
123		}
124		$this->classes[$entityType] = array(
125		'real' => $realClass,
126		'proxy' => $proxyClass
127		);
128		return $this->classes[$entityType];
129		}
130
131		/**
132		* {@inheritdoc}
133		*/
134		public function getPropertyMapDefinition($entityType) {
		0 ignored issues – show Documentation introduced 2016-06-24 12:13 UTC by Report Bug Copy Issue Report The return type could not be reliably inferred; please add a `@return` annotation. Our type inference engine in quite powerful, but sometimes the code does not provide enough clues to go by. In these cases we request you to add a `@return` annotation as described here. Loading history...
135		if (!isset($this->propertyMapDefinitions[$entityType])) {
136		$propertyMapDefinition = new \ReflectionMethod($this->getClass($entityType), 'getPropertyMapDefinition');
		1 ignored issue – show Coding Style introduced 2016-06-24 12:13 UTC by Report Bug Copy Issue Report Equals sign not aligned with surrounding assignments; expected 21 spaces but found 1 space This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a"; $ab = "ab"; $abc = "abc"; will produce issues in the first and second line, while this second example $a = "a"; $ab = "ab"; $abc = "abc"; will produce no issues. Loading history...
137		$this->propertyMapDefinitions[$entityType] = $propertyMapDefinition->invoke(NULL);
138		}
139		return $this->propertyMapDefinitions[$entityType];
140		}
141
142		/**
143		* {@inheritdoc}
144		*/
145		public function getClass($entityType, $type = 'real') {
146		if (!isset($this->classes[$entityType][$type])) {
147		throw new \Exception(ucfirst($type) . ' class for ' . $entityType . ' not registered.');
148		}
149		return $this->classes[$entityType][$type];
150		}
151
152		/**
153		* {@inheritdoc}
154		*/
155		public function mapProperties(\stdClass $values, $entityType) {
156		$mapped = new \stdClass();
157		foreach ($this->getPropertyMapDefinition($entityType) as $propertyDefinition) {
158		$mapped->{$propertyDefinition[1]} = NULL;
159	View Code Duplication	if (!isset($values->{$propertyDefinition[0]})) {
		1 ignored issue – show Duplication introduced 2016-06-24 12:00 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...
160		$values->{$propertyDefinition[0]} = static::EMPTYPROPERTYPLACEHOLDER;
161		}
162		}
163		return $this->sanitizeObject($this->propertyMapper->process($values, $mapped, $this->getPropertyMap($entityType)));
		1 ignored issue – show Documentation introduced 2016-06-24 12:00 UTC by Report Bug Copy Issue Report `$this->propertyMapper->p...opertyMap($entityType))` is of type `array\|object`, but the function expects a `object<stdClass>`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
164		}
165
166
167		/**
168		* {@inheritdoc}
169		*/
170		public function reverseMapProperties(\stdClass $values, $entityType) {
171		$reversed = new \stdClass();
172		foreach ($this->getPropertyMapDefinition($entityType) as $propertyDefinition) {
173		if (!isset($reversed->{$propertyDefinition[0]})) {
174		$reversed->{$propertyDefinition[0]} = static::EMPTYPROPERTYPLACEHOLDER;
175		}
176	View Code Duplication	if (!isset($values->{$propertyDefinition[1]})) {
		1 ignored issue – show Duplication introduced 2016-06-24 12:00 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...
177		$values->{$propertyDefinition[1]} = static::EMPTYPROPERTYPLACEHOLDER;
178		}
179		}
180		return $this->sanitizeObject($this->propertyMapper->reverse($reversed, $values, $this->getPropertyMap($entityType)));
		1 ignored issue – show Documentation introduced 2016-06-24 12:00 UTC by Report Bug Copy Issue Report `$this->propertyMapper->r...opertyMap($entityType))` is of type `array\|object`, but the function expects a `object<stdClass>`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
181		}
182
183		/**
184		* {@inheritdoc}
185		*/
186		public function isFullObject(\stdClass $object, $entityType) {
187		$reflection = new \ReflectionClass($this->getClass($entityType));
		1 ignored issue – show Coding Style introduced 2016-06-27 13:13 UTC by Report Bug Copy Issue Report Equals sign not aligned with surrounding assignments; expected 8 spaces but found 1 space This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a"; $ab = "ab"; $abc = "abc"; will produce issues in the first and second line, while this second example $a = "a"; $ab = "ab"; $abc = "abc"; will produce no issues. Loading history...
188		$defaultProperties = $reflection->getDefaultProperties();
189		$properties = array_flip(array_filter(array_keys($defaultProperties), function($prop) use ($reflection) {
		1 ignored issue – show Coding Style introduced 2016-06-24 12:13 UTC by Report Bug Copy Issue Report Equals sign not aligned with surrounding assignments; expected 8 spaces but found 1 space This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a"; $ab = "ab"; $abc = "abc"; will produce issues in the first and second line, while this second example $a = "a"; $ab = "ab"; $abc = "abc"; will produce no issues. Loading history...
190		// Filter out static properties.
191		$reflectionProp = $reflection->getProperty($prop);
192		if ($reflectionProp->isStatic()) {
		0 ignored issues – show Unused Code introduced 2016-06-27 13:13 UTC by Report Bug Copy Issue Report This `if` statement, and the following `return` statement can be replaced with `return !$reflectionProp->isStatic();`. Loading history...
193		return FALSE;
194		}
195		return TRUE;
196		}));
197		return count(array_intersect_key($properties, (array) $object)) === count($properties);
198		}
199
200		/**
201		* Initializes the property map.
202		* @param string $entityType
203		*/
204		protected function initPropertyMap($entityType) {
205		$this->propertyMaps[$entityType] = new Map();
206		$entityManager = $this;
		1 ignored issue – show Coding Style introduced 2016-06-24 12:13 UTC by Report Bug Copy Issue Report Equals sign not aligned with surrounding assignments; expected 19 spaces but found 1 space This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a"; $ab = "ab"; $abc = "abc"; will produce issues in the first and second line, while this second example $a = "a"; $ab = "ab"; $abc = "abc"; will produce no issues. Loading history...
207		foreach ($this->getPropertyMapDefinition($entityType) as $args) {
208		if (isset($args[2]) && is_array($args[2])) {
209		$transform = $args[2][0];
210		$reverse = $args[2][1];
		1 ignored issue – show Coding Style introduced 2016-06-24 12:13 UTC by Report Bug Copy Issue Report Equals sign not aligned with surrounding assignments; expected 3 spaces but found 1 space This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a"; $ab = "ab"; $abc = "abc"; will produce issues in the first and second line, while this second example $a = "a"; $ab = "ab"; $abc = "abc"; will produce no issues. Loading history...
211		$args[2] = new Callback(
		1 ignored issue – show Coding Style introduced 2016-06-24 12:13 UTC by Report Bug Copy Issue Report Equals sign not aligned with surrounding assignments; expected 3 spaces but found 1 space This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a"; $ab = "ab"; $abc = "abc"; will produce issues in the first and second line, while this second example $a = "a"; $ab = "ab"; $abc = "abc"; will produce no issues. Loading history...
212
213		/**
214		* @param string $value
215		*/
216	View Code Duplication	function($value, $context) use ($entityManager, $transform) {
		1 ignored issue – show Duplication introduced 2016-06-24 12:00 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...
217		if ($entityManager->isEmptyValue($value)) {
218		return $value;
219		}
220		return call_user_func_array($transform, array($value, $context, $entityManager));
221		},
222
223		/**
224		* @param string $value
225		*/
226	View Code Duplication	function($value, $context) use ($entityManager, $reverse) {
		1 ignored issue – show Duplication introduced 2016-06-24 12:00 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...
227		if ($entityManager->isEmptyValue($value)) {
228		return $value;
229		}
230		return call_user_func_array($reverse, array($value, $context, $entityManager));
231		}
232		);
233		}
234		call_user_func_array(array($this->propertyMaps[$entityType], 'map'), $args);
235		}
236		}
237
238		/**
239		* Gets the property map.
240		*
241		* @param string $entityType
242		* @return \FastNorth\PropertyMapper\MapInterface
243		* The property map.
244		*/
245		protected function getPropertyMap($entityType) {
246		if (!isset($this->propertyMaps[$entityType])) {
247		$this->initPropertyMap($entityType);
248		}
249		return $this->propertyMaps[$entityType];
250		}
251
252		protected function sanitizeObject(\stdClass $object) {
		0 ignored issues – show Documentation introduced 2016-06-24 12:13 UTC by Report Bug Copy Issue Report The return type could not be reliably inferred; please add a `@return` annotation. Our type inference engine in quite powerful, but sometimes the code does not provide enough clues to go by. In these cases we request you to add a `@return` annotation as described here. Loading history...
253		$arr = (array) $object;
254		foreach ($arr as $prop => $val) {
255		if ($this->isEmptyValue($val)) {
256		unset($arr[$prop]);
257		}
258		}
259		return (object) $arr;
260		}
261
262
263		public function isEmptyValue($value) {
264		return $value === static::EMPTYPROPERTYPLACEHOLDER;
265		}
266		}
267

Jelle-S / TheSportsDb