EdmondsCommerce\DoctrineStaticMeta\Entity\Testing\EntityDebugDumper

Complexity

Total Complexity

14

Size/Duplication

Total Lines	70
Duplicated Lines	0 %

Test Coverage

Coverage

46.43%

Importance

Changes	1
Bugs	0	Features	0

1 Method

Rating	Name	Duplication	Size	Complexity
C	dump()	0	57	14

<?php

declare(strict_types=1);

namespace EdmondsCommerce\DoctrineStaticMeta\Entity\Testing;

use Doctrine\Common\Collections\Collection;
use Doctrine\Common\Util\Debug;
use Doctrine\ORM\EntityManagerInterface;
use Doctrine\ORM\Proxy\Proxy;
use EdmondsCommerce\DoctrineStaticMeta\Entity\Interfaces\EntityInterface;
use ReflectionException;
use RuntimeException;
use TypeError;

use function get_class;
use function is_numeric;
use function lcfirst;
use function preg_replace;

/**
 * @SuppressWarnings(PHPMD.NPathComplexity)
 */
class EntityDebugDumper
{
    /**
     * @param EntityInterface        $entity
     * @param EntityManagerInterface $entityManager
     * @param int                    $level
     *
     * @return string
     * @throws ReflectionException
     * @SuppressWarnings(PHPMD.StaticAccess)
     * @SuppressWarnings(PHPMD.ElseExpression)
     * @SuppressWarnings(PHPMD.CyclomaticComplexity)
     */
    public function dump(EntityInterface $entity, ?EntityManagerInterface $entityManager = null, int $level = 0): string
    {
        $dump          = [];
        $fieldMappings = [];
        if (null !== $entityManager) {
            $metaData      = $entityManager->getClassMetadata(get_class($entity));
            $fieldMappings = $metaData->fieldMappings;

Accessing fieldMappings on the interface Doctrine\Common\Persistence\Mapping\ClassMetadata suggest that you code against a concrete implementation. How about adding an instanceof check?

        }
        foreach ($entity::getDoctrineStaticMeta()->getGetters() as $getter) {
            try {
                $got = $entity->$getter();
            } catch (TypeError $e) {
                $got = '( *TypeError*: ' . $e->getMessage() . ' )';
            }
            $fieldName = lcfirst(preg_replace('%^(get|is)%', '', $getter));
            if (
                is_numeric($got)
                || (isset($fieldMappings[$fieldName])
                && 'decimal' === $fieldMappings[$fieldName]['type'])
            ) {
                $dump[$getter] = (float)$got;
                continue;
            }
            if ($got instanceof Proxy) {
                $dump[$getter] = 'Proxy class ';
                continue;
            }
            if ($got instanceof EntityInterface) {
                if ($level === 2) {
                    $dump[$getter] = '(max depth of 2 reached)';
                    continue;
                }
                $dump[$getter] = $this->dump($got, $entityManager, ++$level);
                continue;
            }
            if ($got instanceof Collection) {
                $dump[$getter] = [];
                foreach ($got as $item) {
                    if ($item instanceof EntityInterface) {
                        $dump[$getter][] = get_class($item) . ': ' . $item->getId();

Are you sure $item->getId() of type Ramsey\Uuid\UuidInterface can be used in concatenation? Consider adding a __toString()-method.

                        continue;
                    }
                    throw new RuntimeException('Got unexpected object ' .
                                                get_class($got) .
                                                ' in collection from ' .
                                                $getter);
                }
                continue;
            }
            if (method_exists($got, '__toString')) {
                $dump[$getter] = (string)$got;
                continue;
            }
            $dump[$getter] = Debug::export($got, 2);
        }

        return (string)print_r($dump, true);
    }
}