DoctrineHelper::getEntityManagerFromOnFlushEventArgs() - Code Metrics - Inspection of "Fix deprecations" - DamienHarper/auditor - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#124)

unknown

created 2022-11-07 06:17 UTC

getEntityManagerFromOnFlushEventArgs() A

↳ Parent: DoctrineHelper

Complexity

Conditions	2
Paths	2

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	1
c	0
b	0
f	0
dl	0
loc	3
rs	10
cc	2
nc	2
nop	1

<?php

declare(strict_types=1);

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

use Doctrine\DBAL\Connection;
use Doctrine\DBAL\Query\QueryBuilder;
use Doctrine\DBAL\Schema\AbstractSchemaManager;
use Doctrine\DBAL\Schema\Comparator;
filter:
    dependency_paths: ["lib/*"]
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;

/**
 * @see \DH\Auditor\Tests\Provider\Doctrine\Persistence\Helper\DoctrineHelperTest
 */
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();
            /** @scrutinizer ignore-deprecated */ $statement->execute();
        }
    }

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

    public static function createSchemaManager(Connection $connection): AbstractSchemaManager
    {
        return method_exists($connection, 'createSchemaManager')
            ? $connection->createSchemaManager()
            : $connection->getSchemaManager();
            : /** @scrutinizer ignore-deprecated */ $connection->getSchemaManager();
    }

    public static function introspectSchema(AbstractSchemaManager $schemaManager): Schema
    {
        return method_exists($schemaManager, 'introspectSchema')
            ? $schemaManager->introspectSchema()
            : $schemaManager->createSchema();
            : /** @scrutinizer ignore-deprecated */ $schemaManager->createSchema();
    }

    /**
     * @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);
        return /** @scrutinizer ignore-deprecated */ $fromSchema->getMigrateToSql($toSchema, $platform);
    }

    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)) {
            return ORMSetup::createAnnotationMetadataConfiguration($paths, $isDevMode);
        }

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

    public static function getEntityManagerFromOnFlushEventArgs(OnFlushEventArgs $args): EntityManagerInterface
    {
        return method_exists($args, '') ? $args->getObjectManager() : $args->getEntityManager();
        return method_exists($args, '') ? $args->getObjectManager() : /** @scrutinizer ignore-deprecated */ $args->getEntityManager();
    }
}


DamienHarper / auditor

Pull Request — master (#124)

getEntityManagerFromOnFlushEventArgs() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like