PersistentObject::set() - Code Metrics - Inspection of "First commit of Doctrine Persistence project." - doctrine/persistence - Measure and Improve Code Quality continuously with Scrutinizer

Failed Conditions
Pull Request — master (#1)

by Jonathan
created 2018-06-06 18:46 UTC
PersistentObject::set() B

↳ Parent: PersistentObject
Complexity

Conditions	7
Paths	4
Size

Total Lines	13
Code Lines	10
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	10
CRAP Score	7
Importance

Changes
Metric	Value
dl	0
loc	13
ccs	10
cts	10
cp	1
rs	8.2222
c	0
b	0
f	0
cc	7
eloc	10
nc	4
nop	2
crap	7
<?php
namespace Doctrine\Common\Persistence;

use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\Common\Collections\Collection;
use Doctrine\Common\Persistence\Mapping\ClassMetadata;

/**
 * PersistentObject base class that implements getter/setter methods for all mapped fields and associations
 * by overriding __call.
 *
 * This class is a forward compatible implementation of the PersistentObject trait.
 *
 * Limitations:
 *
 * 1. All persistent objects have to be associated with a single ObjectManager, multiple
 *    ObjectManagers are not supported. You can set the ObjectManager with `PersistentObject#setObjectManager()`.
 * 2. Setters and getters only work if a ClassMetadata instance was injected into the PersistentObject.
 *    This is either done on `postLoad` of an object or by accessing the global object manager.
 * 3. There are no hooks for setters/getters. Just implement the method yourself instead of relying on __call().
 * 4. Slower than handcoded implementations: An average of 7 method calls per access to a field and 11 for an association.
 * 5. Only the inverse side associations get autoset on the owning side as well. Setting objects on the owning side
 *    will not set the inverse side associations.
 *
 * @example
 *
 *  PersistentObject::setObjectManager($em);
 *
 *  class Foo extends PersistentObject
 *  {
 *      private $id;
 *  }
 *
 *  $foo = new Foo();
 *  $foo->getId(); // method exists through __call
 *
 * @author Benjamin Eberlei <[email protected]>
 */
abstract class PersistentObject implements ObjectManagerAware
{
    /**
     * @var ObjectManager|null
     */
    private static $objectManager = null;

    /**
     * @var ClassMetadata|null
     */
    private $cm = null;

    /**
     * Sets the object manager responsible for all persistent object base classes.
     *
     * @param ObjectManager|null $objectManager
     *
     * @return void
     */
    public static function setObjectManager(ObjectManager $objectManager = null)
    {
        self::$objectManager = $objectManager;
    }

    /**
     * @return ObjectManager|null
     */
    public static function getObjectManager()
    {
        return self::$objectManager;
    }

    /**
     * Injects the Doctrine Object Manager.
     *
     * @param ObjectManager $objectManager
     * @param ClassMetadata $classMetadata
     *
     * @return void
     *
     * @throws \RuntimeException
     */
    public function injectObjectManager(ObjectManager $objectManager, ClassMetadata $classMetadata)
    {
        if ($objectManager !== self::$objectManager) {
            throw new \RuntimeException("Trying to use PersistentObject with different ObjectManager instances. " .
                "Was PersistentObject::setObjectManager() called?");
        }

        $this->cm = $classMetadata;
    }

    /**
     * Sets a persistent fields value.
     *
     * @param string $field
     * @param array  $args
     *
     * @return void
     *
     * @throws \BadMethodCallException   When no persistent field exists by that name.
     * @throws \InvalidArgumentException When the wrong target object type is passed to an association.
     */
    private function set($field, $args)
    {
        if ($this->cm->hasField($field) && ! $this->cm->isIdentifier($field)) {
        if ($this->cm->/** @scrutinizer ignore-call */ hasField($field) && ! $this->cm->isIdentifier($field)) {
            $this->$field = $args[0];
        } elseif ($this->cm->hasAssociation($field) && $this->cm->isSingleValuedAssociation($field)) {
            $targetClass = $this->cm->getAssociationTargetClass($field);
            if ( ! ($args[0] instanceof $targetClass) && $args[0] !== null) {
                throw new \InvalidArgumentException("Expected persistent object of type '" . $targetClass . "'");
            }
            $this->$field = $args[0];
            $this->completeOwningSide($field, $targetClass, $args[0]);
            $this->completeOwningSide($field, /** @scrutinizer ignore-type */ $targetClass, $args[0]);
        } else {
            throw new \BadMethodCallException("no field with name '" . $field . "' exists on '" . $this->cm->getName() . "'");
        }
    }

    /**
     * Gets a persistent field value.
     *
     * @param string $field
     *
     * @return mixed
     *
     * @throws \BadMethodCallException When no persistent field exists by that name.
     */
    private function get($field)
    {
        if ($this->cm->hasField($field) || $this->cm->hasAssociation($field)) {
            return $this->$field;
        }

        throw new \BadMethodCallException("no field with name '" . $field . "' exists on '" . $this->cm->getName() . "'");
    }

    /**
     * If this is an inverse side association, completes the owning side.
     *
     * @param string        $field
     * @param ClassMetadata $targetClass
     * @param object        $targetObject
     *
     * @return void
     */
    private function completeOwningSide($field, $targetClass, $targetObject)
    {
        // add this object on the owning side as well, for obvious infinite recursion
        // reasons this is only done when called on the inverse side.
        if ($this->cm->isAssociationInverseSide($field)) {
            $mappedByField  = $this->cm->getAssociationMappedByTargetField($field);
            $targetMetadata = self::$objectManager->getClassMetadata($targetClass);
            $targetMetadata = self::$objectManager->getClassMetadata($targetClass);

            $setter = ($targetMetadata->isCollectionValuedAssociation($mappedByField) ? "add" : "set") . $mappedByField;
            $targetObject->$setter($this);
        }
    }

    /**
     * Adds an object to a collection.
     *
     * @param string $field
     * @param array  $args
     *
     * @return void
     *
     * @throws \BadMethodCallException
     * @throws \InvalidArgumentException
     */
    private function add($field, $args)
    {
        if ($this->cm->hasAssociation($field) && $this->cm->isCollectionValuedAssociation($field)) {
            $targetClass = $this->cm->getAssociationTargetClass($field);
            if ( ! ($args[0] instanceof $targetClass)) {
                throw new \InvalidArgumentException("Expected persistent object of type '" . $targetClass . "'");
            }
            if ( ! ($this->$field instanceof Collection)) {
                $this->$field = new ArrayCollection($this->$field ?: []);
            }
            $this->$field->add($args[0]);
            $this->completeOwningSide($field, $targetClass, $args[0]);
            $this->completeOwningSide($field, /** @scrutinizer ignore-type */ $targetClass, $args[0]);
        } else {
            throw new \BadMethodCallException("There is no method add" . $field . "() on " . $this->cm->getName());
        }
    }

    /**
     * Initializes Doctrine Metadata for this class.
     *
     * @return void
     *
     * @throws \RuntimeException
     */
    private function initializeDoctrine()
    {
        if ($this->cm !== null) {
            return;
        }

        if ( ! self::$objectManager) {
            throw new \RuntimeException("No runtime object manager set. Call PersistentObject#setObjectManager().");
        }

        $this->cm = self::$objectManager->getClassMetadata(get_class($this));
    }

    /**
     * Magic methods.
     *
     * @param string $method
     * @param array  $args
     *
     * @return mixed
     *
     * @throws \BadMethodCallException
     */
    public function __call($method, $args)
    {
        $this->initializeDoctrine();

        $command = substr($method, 0, 3);
        $field   = lcfirst(substr($method, 3));
        if ($command == "set") {
            $this->set($field, $args);
        } elseif ($command == "get") {
            return $this->get($field);
        } elseif ($command == "add") {
            $this->add($field, $args);
        } else {
            throw new \BadMethodCallException("There is no method " . $method . " on " . $this->cm->getName());
        }
    }
}

doctrine / persistence

Pull Request — master (#1)

PersistentObject::set() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
