DH\Auditor\Provider\Doctrine\Persistence\Helper\DoctrineHelper

Complexity

Total Complexity

24

Size/Duplication

Total Lines	141
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	createAttributeMetadataConfiguration()	0	7	2
A	getRealClassName()	0	20	5
A	getMigrateToSql()	0	12	2
A	getDoctrineType()	0	9	2
A	createAnnotationMetadataConfiguration()	0	9	2
A	createSchemaManager()	0	5	2
A	getEntityManagerFromOnFlushEventArgs()	0	3	2
A	executeQuery()	0	7	2
A	executeStatement()	0	6	2
A	introspectSchema()	0	5	2
A	getVendorDir()	0	7	1

<?php

declare(strict_types=1);

namespace DH\Auditor\Provider\Doctrine\Persistence\Helper;

use Composer\Autoload\ClassLoader;
use Doctrine\DBAL\Connection;
use Doctrine\DBAL\Query\QueryBuilder;
use Doctrine\DBAL\Result;
use Doctrine\DBAL\Schema\AbstractSchemaManager;
use Doctrine\DBAL\Schema\Comparator;

The type Doctrine\DBAL\Schema\Comparator was not found. Maybe you did not declare it correctly or list all dependencies?

use Doctrine\DBAL\Schema\Schema;
use Doctrine\DBAL\Statement;
use Doctrine\DBAL\Types\Types;
use Doctrine\ORM\Configuration;
use Doctrine\ORM\EntityManagerInterface;
use Doctrine\ORM\Event\OnFlushEventArgs;
use Doctrine\ORM\ORMSetup;
use Doctrine\ORM\Tools\Setup;
use InvalidArgumentException;
use ReflectionClass;

/**
 * @see \DH\Auditor\Tests\Provider\Doctrine\Persistence\Helper\DoctrineHelperTest
 *
 * @internal
 */
final class DoctrineHelper
{
    /**
     * Gets the real class name of a class name that could be a proxy.
     *
     * @param object|string $subject
     *
     * @return string
     *
     * credits
     * https://github.com/api-platform/core/blob/master/src/Util/ClassInfoTrait.php
     */
    public static function getRealClassName($subject): string
    {
        $subject = \is_object($subject) ? \get_class($subject) : $subject;

        // __CG__: Doctrine Common Marker for Proxy (ODM < 2.0 and ORM < 3.0)
        // __PM__: Ocramius Proxy Manager (ODM >= 2.0)
        $positionCg = mb_strrpos($subject, '\\__CG__\\');
        $positionPm = mb_strrpos($subject, '\\__PM__\\');
        if (false === $positionCg && false === $positionPm) {
            return $subject;
        }
        if (false !== $positionCg) {
            return mb_substr($subject, $positionCg + 8);
        }
        $className = ltrim($subject, '\\');

        return mb_substr(
            $className,
            8 + $positionPm,
            mb_strrpos($className, '\\') - ($positionPm + 8)
        );
    }

    public static function getDoctrineType(string $type): string
    {
        if (!\defined(Types::class.'::'.$type)) {
            throw new InvalidArgumentException(sprintf('Undefined Doctrine type "%s"', $type));
        }

        \assert(\is_string(\constant(Types::class.'::'.$type)));

        return \constant(Types::class.'::'.$type);
    }

    /**
     * @param QueryBuilder|Statement $statement
     *
     * @throws \Doctrine\DBAL\Exception
     */
    public static function executeStatement($statement): void
    {
        if (method_exists($statement, 'executeStatement')) {
            $statement->executeStatement();
        } else {
            $statement->execute();

The function Doctrine\DBAL\Statement::execute() has been deprecated: Statement::execute() is deprecated, use Statement::executeQuery() or executeStatement() instead

The function Doctrine\DBAL\Query\QueryBuilder::execute() has been deprecated: Use {@see executeQuery()} or {@see executeStatement()} instead.

        }
    }

    /**
     * @param QueryBuilder|Statement $statement
     *
     * @return int|Result|string
     *
     * @throws \Doctrine\DBAL\Exception
     */
    public static function executeQuery($statement)
    {
        if (method_exists($statement, 'executeQuery')) {
            return $statement->executeQuery();
        }

        return $statement->execute();

The function Doctrine\DBAL\Statement::execute() has been deprecated: Statement::execute() is deprecated, use Statement::executeQuery() or executeStatement() instead

The function Doctrine\DBAL\Query\QueryBuilder::execute() has been deprecated: Use {@see executeQuery()} or {@see executeStatement()} instead.

    }

    public static function createSchemaManager(Connection $connection): AbstractSchemaManager
    {
        return method_exists($connection, 'createSchemaManager')
            ? $connection->createSchemaManager()
            : $connection->getSchemaManager();

The function Doctrine\DBAL\Connection::getSchemaManager() has been deprecated: Use {@see createSchemaManager()} instead.

    }

    public static function introspectSchema(AbstractSchemaManager $schemaManager): Schema
    {
        return method_exists($schemaManager, 'introspectSchema')
            ? $schemaManager->introspectSchema()
            : $schemaManager->createSchema();

The function Doctrine\DBAL\Schema\AbstractSchemaManager::createSchema() has been deprecated: Use {@link introspectSchema()} instead.

    }

    /**
     * @return array<string>
     *
     * @throws \Doctrine\DBAL\Exception
     */
    public static function getMigrateToSql(Connection $connection, Schema $fromSchema, Schema $toSchema): array
    {
        $schemaComparator = new Comparator();
        $platform = $connection->getDatabasePlatform();

        if (method_exists($platform, 'getAlterSchemaSQL')) {
            return $platform->getAlterSchemaSQL(
                $schemaComparator->compareSchemas($fromSchema, $toSchema)
            );
        }

        return $fromSchema->getMigrateToSql($toSchema, $platform);

The function Doctrine\DBAL\Schema\Schema::getMigrateToSql() has been deprecated.

    }

    public static function createAttributeMetadataConfiguration(array $paths, bool $isDevMode = false): Configuration
    {
        if (class_exists(ORMSetup::class)) {
            return ORMSetup::createAttributeMetadataConfiguration($paths, $isDevMode);
        }

        return Setup::createAttributeMetadataConfiguration($paths, $isDevMode);
    }

    public static function createAnnotationMetadataConfiguration(array $paths, bool $isDevMode = false): Configuration
    {
        if (class_exists(ORMSetup::class)) {
            require_once self::getVendorDir().'/doctrine/orm/lib/Doctrine/ORM/Mapping/Driver/DoctrineAnnotations.php';

            return ORMSetup::createAnnotationMetadataConfiguration($paths, $isDevMode);
        }

        return Setup::createAnnotationMetadataConfiguration($paths, $isDevMode, null, null, false);
    }

    public static function getEntityManagerFromOnFlushEventArgs(OnFlushEventArgs $args): EntityManagerInterface
    {
        return method_exists($args, 'getObjectManager') ? $args->getObjectManager() : $args->getEntityManager();

The expression return method_exists($args, 'getObjectManager') ? $args->getObjectManager() : $args->getEntityManager() could return the type Doctrine\Persistence\ObjectManager which includes types incompatible with the type-hinted return Doctrine\ORM\EntityManagerInterface. Consider adding an additional type-check to rule them out.

The function Doctrine\ORM\Event\OnFlushEventArgs::getEntityManager() has been deprecated: 2.13. Use {@see getObjectManager} instead.

    }

    public static function getVendorDir(): string
    {
        $reflection = new ReflectionClass(ClassLoader::class);
        $filename = $reflection->getFileName();
        \assert(\is_string($filename));

        return \dirname($filename, 2);
    }
}