objectmanager - Code Metrics - Inspection of "Bring coding style close in line with psr-2" - flack/midgard-portable - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 1af4f5...caaac4 )

by Andreas

created 2016-11-11 10:43 UTC

objectmanager A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	229
Duplicated Lines	21.4 %

Coupling/Cohesion

Components	1
Dependencies	9

Test Coverage

Coverage

94.63%

Importance

Changes	5
Bugs	0	Features	0

Metric	Value
dl	49
loc	229
ccs	141
cts	149
cp	0.9463
rs	10
c	5
b	0
f	0
wmc	30
lcom	1
cbo	9

14 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	create()	5	20	4
A	update()	0	14	1
A	copy_associations()	0	6	2
B	kill_potential_proxies()	0	20	5
A	delete()	5	23	2
A	undelete()	0	9	1
A	purge()	0	18	2
A	approve()	13	13	1
A	unapprove()	13	13	1
A	lock()	13	13	1
A	unlock()	0	10	1
A	new_instance()	0	17	3
B	copy_metadata()	0	22	5

How to fix Duplicated Code

<?php
/**
 * @author CONTENT CONTROL http://www.contentcontrol-berlin.de/
 * @copyright CONTENT CONTROL http://www.contentcontrol-berlin.de/
 * @license http://www.gnu.org/licenses/gpl.html GNU General Public License
 */

namespace midgard\portable\storage;

use midgard\portable\api\dbobject;
use midgard\portable\api\error\exception;
use midgard\portable\storage\metadata\entity;
use Doctrine\ORM\EntityManager;
use Doctrine\ORM\Proxy\Proxy;
use Doctrine\ORM\UnitOfWork;
use Doctrine\Common\Util\ClassUtils;
use midgard_datetime;

class objectmanager
{
    private $em;

    public function __construct(EntityManager $em)
function someFunction(ManagerRegistry $registry) {
    $em = $registry->getManager();
    $em->getConnection()->beginTransaction();
    try {
        // Do something.
        $em->getConnection()->commit();
    } catch (\Exception $ex) {
        $em->getConnection()->rollback();
        $em->close();

        throw $ex;
    }
}
    {
        $this->em = $em;
    }

    public function create(dbobject $entity)
    {
        foreach ($this->em->getClassMetadata(get_class($entity))->getAssociationNames() as $name) {
            if (!empty($entity->$name)) {
                //This makes sure that we don't have stale references
                $entity->$name = $entity->$name;
            }
        }

        //workaround for possible oid collisions in UnitOfWork
        //see http://www.doctrine-project.org/jira/browse/DDC-2785
        if ($this->em->getUnitOfWork()->getEntityState($entity) != UnitOfWork::STATE_NEW) {

            connection::log()->warning('oid collision during create detected, detaching ' . spl_object_hash($entity));
            $this->em->detach($entity);
        }

        $this->em->persist($entity);
        $this->em->flush($entity);
        $this->em->detach($entity);
    }

    public function update(dbobject $entity)
    {
        // if entities are loaded by querybuilder, they are managed at this point already,
        // which can in very rare (and very unreproducable) circumstances lead to the update
        // getting lost silently (because originalEntityData somehow is empty), so we detach
        // before doing anything else
        $this->em->detach($entity);
        $merged = $this->em->merge($entity);
        $this->copy_associations($entity, $merged);
        $this->em->persist($merged);
        $this->em->flush($merged);
        $this->em->detach($merged);
        $this->copy_metadata($merged, $entity);
    }

    /**
     * This is basically a workaround for some quirks when merging detached entities with changed associations
     *
     * @todo: This may or may not be a bug in Doctrine
     */
    private function copy_associations($source, $target)
    {
        foreach ($this->em->getClassMetadata(get_class($source))->getAssociationNames() as $name) {
            $target->$name = $source->$name;
        }
    }

    private function kill_potential_proxies($entity)
    {
        $classname = ClassUtils::getRealClass(get_class($entity));
        $cm = $this->em->getClassMetadata($classname);
        $changed_associations = $entity->__get_changed_associations();

        foreach ($cm->getAssociationNames() as $name) {
            if ($entity->$name === 0) {
                //This is necessary to kill potential proxy objects pointing to purged entities
                $entity->$name = 0;
            } elseif (!array_key_exists($name, $changed_associations)) {
                $value = $cm->getReflectionProperty($name)->getValue($entity);
                if ($value instanceof Proxy) {
                    //This makes sure that the associated entity doesn't end up in the changeset calculation
                    $value->__isInitialized__ = false;
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

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

    public function delete(dbobject $entity)
    {
        //we might deal with a proxy here, so we translate the classname
        $classname = ClassUtils::getRealClass(get_class($entity));
        $copy = new $classname($entity->id);
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}

        //workaround for possible oid collisions in UnitOfWork
        //see http://www.doctrine-project.org/jira/browse/DDC-2785
        if ($this->em->getUnitOfWork()->getEntityState($copy) != UnitOfWork::STATE_DETACHED) {

            connection::log()->warning('oid collision during delete detected, detaching ' . spl_object_hash($copy));
            $this->em->detach($copy);
        }

        $copy = $this->em->merge($copy);
        $this->kill_potential_proxies($copy);
        $copy->metadata_deleted = true;

        $this->em->persist($copy);
        $this->em->flush($copy);
        $this->em->detach($copy);
        $this->em->detach($entity);
        $this->copy_metadata($copy, $entity, 'delete');
    }

    public function undelete(dbobject $entity)
    {
        $entity->metadata_deleted = false;
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
        $this->kill_potential_proxies($entity);

        $this->em->persist($entity);
        $this->em->flush($entity);
        $this->em->detach($entity);
    }

    public function purge(dbobject $entity)
    {
        $this->em->getFilters()->disable('softdelete');
        try {
            $entity = $this->em->merge($entity);
            // If we don't refresh here, Doctrine might try to update before deleting and
            // throw exceptions about new entities being found (most likely stale association proxies)
            // @todo: In Doctrine 2.5, this behavior should be removed, so we may be able to remove this workaround
            $this->em->refresh($entity);
        } catch (\Exception $e) {
            $this->em->getFilters()->enable('softdelete');
            throw $e;
        }
        $this->em->getFilters()->enable('softdelete');
        $this->em->remove($entity);
        $this->em->flush($entity);
        $this->em->detach($entity);
    }

    public function approve(dbobject $entity)

    {
        $user = connection::get_user();
        $ref = $this->em->getReference(get_class($entity), $entity->id);
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
        $ref->metadata_isapproved = true;
        $ref->metadata_approver = $user->person;
        $ref->metadata_approved = new midgard_datetime;

        $this->em->persist($ref);
        $this->em->flush($ref);
        $this->em->detach($entity);
        $this->copy_metadata($ref, $entity, 'approve');
    }

    public function unapprove(dbobject $entity)

    {
        $user = connection::get_user();
        $ref = $this->em->getReference(get_class($entity), $entity->id);
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
        $ref->metadata_isapproved = false;
        $ref->metadata_approver = $user->person;
        $ref->metadata_approved = new midgard_datetime;

        $this->em->persist($ref);
        $this->em->flush($ref);
        $this->em->detach($entity);
        $this->copy_metadata($ref, $entity, 'approve');
    }

    public function lock(dbobject $entity)

    {
        $user = connection::get_user();
        $ref = $this->em->getReference(get_class($entity), $entity->id);
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
        $ref->metadata_islocked = true;
        $ref->metadata_locker = $user->person;
        $ref->metadata_locked = new midgard_datetime;

        $this->em->persist($ref);
        $this->em->flush($ref);
        $this->em->detach($entity);
        $this->copy_metadata($ref, $entity, 'lock');
    }

    public function unlock(dbobject $entity)
    {
        $ref = $this->em->getReference(get_class($entity), $entity->id);
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
        $ref->metadata_islocked = false;

        $this->em->persist($ref);
        $this->em->flush($ref);
        $this->em->detach($entity);
        $this->copy_metadata($ref, $entity, 'lock');
    }

    /**
     * @param string $classname
     * @return dbobject
     */
    public function new_instance($classname)
    {
        //workaround for possible oid collisions in UnitOfWork
        //see http://www.doctrine-project.org/jira/browse/DDC-2785
        $counter = 0;
        $candidates = array();
        do {
            $entity = new $classname;
            if ($counter++ > 100) {
                throw new exception('Failed to create fresh ' . $classname . ' instance (all tried oids are already known to UoW)');
            }
            //we keep the entity in memory to make sure we get a different oid during the next iteration
            $candidates[] = $entity;
        } while ($this->em->getUnitOfWork()->getEntityState($entity) !== UnitOfWork::STATE_NEW);
        // TODO: Calling $em->getUnitOfWork()->isInIdentityMap($entity) returns false in the same situation. Why?
        return $entity;
    }

    private function copy_metadata($source, $target, $action = 'update')
    {
        if (!$source instanceof entity) {
            return;
        }

        $target->metadata_revised = $source->metadata_revised;
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
        $target->metadata_revisor = $source->metadata_revisor;
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
        $target->metadata_revision = $source->metadata_revision;
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

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

        if ($action == 'lock') {
            $target->metadata_islocked = $source->metadata_islocked;
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            $target->metadata_locker = $source->metadata_locker;
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            $target->metadata_locked = $source->metadata_locked;
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
        } elseif ($action == 'approve') {
            $target->metadata_isapproved = $source->metadata_isapproved;
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            $target->metadata_approver = $source->metadata_approver;
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            $target->metadata_approved = $source->metadata_approved;
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
        } elseif ($action == 'delete') {
            $target->metadata_deleted = $source->metadata_deleted;
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

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


Push — master ( 1af4f5...caaac4 )

objectmanager A

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

14 Methods

How to fix Duplicated Code

Duplicated Code

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

1			<?php
2			/**
3			* @author CONTENT CONTROL http://www.contentcontrol-berlin.de/
4			* @copyright CONTENT CONTROL http://www.contentcontrol-berlin.de/
5			* @license http://www.gnu.org/licenses/gpl.html GNU General Public License
6			*/
7
8			namespace midgard\portable\storage;
9
10			use midgard\portable\api\dbobject;
11			use midgard\portable\api\error\exception;
12			use midgard\portable\storage\metadata\entity;
13			use Doctrine\ORM\EntityManager;
14			use Doctrine\ORM\Proxy\Proxy;
15			use Doctrine\ORM\UnitOfWork;
16			use Doctrine\Common\Util\ClassUtils;
17			use midgard_datetime;
18
19			class objectmanager
20			{
21			private $em;
22
23	102		public function __construct(EntityManager $em)
			0 ignored issues – show Bug introduced 2016-11-01 17:19 UTC by Report Bug Copy Issue Report You have injected the EntityManager via parameter `$em`. This is generally not recommended as it might get closed and become unusable. Instead, it is recommended to inject the ManagerRegistry and retrieve the EntityManager via `getManager()` each time you need it. The `EntityManager` might become unusable for example if a transaction is rolled back and it gets closed. Let’s assume that somewhere in your application, or in a third-party library, there is code such as the following: function someFunction(ManagerRegistry $registry) { $em = $registry->getManager(); $em->getConnection()->beginTransaction(); try { // Do something. $em->getConnection()->commit(); } catch (\Exception $ex) { $em->getConnection()->rollback(); $em->close(); throw $ex; } } If that code throws an exception and the `EntityManager` is closed. Any other code which depends on the same instance of the `EntityManager` during this request will fail. On the other hand, if you instead inject the `ManagerRegistry`, the `getManager()` method guarantees that you will always get a usable manager instance. Loading history...
24			{
25	102		$this->em = $em;
26	102		}
27
28	102		public function create(dbobject $entity)
29			{
30	102		foreach ($this->em->getClassMetadata(get_class($entity))->getAssociationNames() as $name) {
31	89		if (!empty($entity->$name)) {
32			//This makes sure that we don't have stale references
33	28		$entity->$name = $entity->$name;
34	28		}
35	102		}
36
37			//workaround for possible oid collisions in UnitOfWork
38			//see http://www.doctrine-project.org/jira/browse/DDC-2785
39	102	View Code Duplication	if ($this->em->getUnitOfWork()->getEntityState($entity) != UnitOfWork::STATE_NEW) {

flack / midgard-portable

Push — master ( 1af4f5...caaac4 )

objectmanager A

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

14 Methods

How to fix Duplicated Code

Duplicated Code

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like