TheSportsDb\Entity\Proxy\Proxy

Complexity

Total Complexity

25

Size/Duplication

Total Lines	138
Duplicated Lines	6.52 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes	5
Bugs	2	Features	0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
B	update()	0	10	5
A	setEntityManager()	0	6	1
A	setSportsDbClient()	0	3	1
A	get()	0	17	4
	load()	0	1	?
C	raw()	9	32	11
A	getEntityType()	0	4	1
A	getPropertyMapDefinition()	0	4	1

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

namespace TheSportsDb\Entity\Proxy;

use TheSportsDb\Http\TheSportsDbClientInterface;
use TheSportsDb\Entity\EntityManagerInterface;
use TheSportsDb\Entity\EntityInterface;
use TheSportsDb\Entity\EntityManagerConsumerTrait;

/**
 * Default implementation of proxy objects.
 *
 * @author Jelle Sebreghts
 */
abstract class Proxy implements ProxyInterface {

Proxy does not seem to conform to the naming convention (^Abstract|Factory$).

  use EntityManagerConsumerTrait;
  /**
   * The sports db client.
   *
   * @var TheSportsDb\Http\TheSportsDbClientInterface
   */
  protected $sportsDbClient;

  /**
   * The already available properties.
   *
   * @var \stdClass
   */
  protected $properties;

  /**
   * The fully loaded entity object (lazy-loaded when needed).
   *
   * @var mixed
   */
  protected $entity;

  /**
   * Creates a new Proxy object.
   *
   * @param \stdClass $values
   *   The sport data.
   * @param \TheSportsDb\Http\TheSportsDbClientInterface $sportsDbClient

There is no parameter named $sportsDbClient. Was it maybe removed?

   *   A sports db client
   * @param \TheSportsDb\Entity\Factory\FactoryInterface $factory

There is no parameter named $factory. Was it maybe removed?

   *   The sport factory.
   */
  public function __construct(\stdClass $values) {
    $this->properties = new \stdClass();
    $this->update($values);
  }

  public function update(\stdClass $values) {
    foreach ((array) $values as $prop => $val) {
      if (method_exists($this, 'get' . ucfirst($prop))) {
        $this->properties->{$prop} = $val;
      }
    }
    if ($this->entityManager && $this->entityManager->factory($this->getEntityType())->isFullObject($this->properties, $this->getEntityType())) {
      $this->entity = $this->entityManager->factory($this->getEntityType())->create($this->properties, $this->getEntityType(), FALSE);
    }
  }

  public function setEntityManager(EntityManagerInterface $entityManager) {
    $this->entityManager = $entityManager;

It seems like $entityManager of type object<TheSportsDb\Entity\EntityManagerInterface> is incompatible with the declared type object<TheSportsDb\Entity\TheSportsDb\Entity\EntityManagerInterface> of property $entityManager.

    // Check if we can create a full object once the entity manager is set.
    $stub = new \stdClass();
    $this->update($stub);
  }

  public function setSportsDbClient(TheSportsDbClientInterface $sportsDbClient) {
    $this->sportsDbClient = $sportsDbClient;

It seems like $sportsDbClient of type object<TheSportsDb\Http\TheSportsDbClientInterface> is incompatible with the declared type object<TheSportsDb\Entity\Proxy\TheSportsDb\Http\TheSportsDbClientInterface> of property $sportsDbClient.

  }

  /**
   * Gets a property, if it exists, loads it if necessary.
   *
   * @param string $name
   *   The property name.
   *
   * @return mixed
   *   The property value.
   */
  protected function get($name) {
    // If the full entity is loaded, use it.
    if ($this->entity instanceof EntityInterface) {
      return $this->entity->{'get' . ucfirst($name)}();
    }

        // If the property exists on the proxy, use it.
    if (isset($this->properties->{$name})) {
      return $this->properties->{$name};
    }

    // The property does not exist on the proxy, and the entity is not loaded in
    // full yet, so load it first and repeat the operation.
    method_exists($this, 'load' . ucfirst($name)) ? $this->{'load' . ucfirst($name)}() : $this->load();
    return $this->get($name);
    
  }

  /**
   * Lazy loads an entity.
   *
   * @throws \Exception
   *   When the entity is not found.
   */
  abstract protected function load();

For interfaces and abstract methods it is generally a good practice to add a @return annotation even if it is just @return void or @return null, so that implementors know what to do in the overridden method.

  public function raw() {

The return type could not be reliably inferred; please add a @return annotation.

    if ($this->entity) {
      $this->_raw = $this->entity->raw();

The property _raw does not exist. Did you maybe forget to declare it?

      return $this->_raw;
    }
    if (!isset($this->_raw)) {
      $this->_raw = new \stdClass();
    }
    $reflection = new \ReflectionClass($this);
    $methods = $reflection->getMethods(\ReflectionMethod::IS_PUBLIC);

Equals sign not aligned with surrounding assignments; expected 4 spaces but found 1 space

    foreach ($methods as $method) {
      $methodName = $method->getName();
      if (strpos($methodName, 'get') === 0) {
        $prop = lcfirst(substr($methodName, 3));
        if (isset($this->properties->{$prop}) && !property_exists($this->_raw, $prop)) {
          $this->_raw->{$prop} = NULL;
          $val = $this->{$methodName}();

Equals sign not aligned with surrounding assignments; expected 17 spaces but found 1 space

          $this->_raw->{$prop} = $val;
          if (method_exists($val, 'raw')) {

This code seems to be duplicated across your project.

            $this->_raw->{$prop} = $val->raw();
          }
          elseif (is_array($val)) {
            $this->_raw->{$prop} = array();
            foreach ($val as $v) {
              $this->_raw->{$prop}[] = method_exists($v, 'raw') ? $v->raw() : $v;
            }
          }
        }
      }
    }
    return $this->_raw;
  }

  public static function getEntityType() {
    $reflection = new \ReflectionClass(static::class);
    return strtolower(substr($reflection->getShortName(), 0, -5));
  }

  public static function getPropertyMapDefinition() {
    $reflection = new \ReflectionClass(substr(static::class, 0, -5));
    return $reflection->getStaticPropertyValue('propertyMapDefinition');
  }
}