Legacy::insertData() - Code Metrics - Inspection of "EZP-31420: Moved deleting translation logic from S..." - ezsystems/ezpublish-kernel - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — ezp-31420-merge-up ( ec14fb...141a64 )

unknown

created 2020-05-08 17:59 UTC

Legacy::insertData() B

↳ Parent: Legacy

Complexity

Conditions	9
Paths	42

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	9
nc	42
nop	0
dl	0
loc	60
rs	7.3171
c	0
b	0
f	0

How to fix Long Method

<?php

/**
 * @copyright Copyright (C) eZ Systems AS. All rights reserved.
 * @license For full copyright and license information view LICENSE file distributed with this source code.
 */
namespace eZ\Publish\API\Repository\Tests\SetupFactory;

use Doctrine\DBAL\Connection;
use Doctrine\DBAL\DBALException;
use Doctrine\DBAL\Driver\PDOException;
use Doctrine\DBAL\Schema\Schema;
use eZ\Publish\API\Repository\Tests\LegacySchemaImporter;
use eZ\Publish\Core\Base\ServiceContainer;
use Symfony\Component\DependencyInjection\ContainerBuilder;
use eZ\Publish\API\Repository\Tests\SetupFactory;
use eZ\Publish\API\Repository\Tests\IdManager;
use eZ\Publish\Core\Persistence\Legacy\Content\Type\MemoryCachingHandler as CachingContentTypeHandler;
use eZ\Publish\Core\Persistence\Legacy\Content\Language\CachingHandler as CachingLanguageHandler;
use Exception;
use eZ\Publish\Core\Repository\Values\User\UserReference;
use Symfony\Component\Filesystem\Filesystem;
use eZ\Publish\Core\Base\Container\Compiler;

/**
 * A Test Factory is used to setup the infrastructure for a tests, based on a
 * specific repository implementation to test.
 */
class Legacy extends SetupFactory
{
    /**
     * Data source name.
     *
     * @var string
     */
    protected static $dsn;

    /**
     * Root dir for IO operations.
     *
     * @var string
     */
    protected static $ioRootDir;

    /**
     * Database type (sqlite, mysql, ...).
     *
     * @var string
     */
    protected static $db;

    /**
     * Service container.
     *
     * @var \eZ\Publish\Core\Base\ServiceContainer
     */
    protected static $serviceContainer;

    /**
     * If the DB schema has already been initialized.
     *
     * @var bool
     */
    protected static $schemaInitialized = false;

    /**
     * Initial database data.
     *
     * @var array
     */
    protected static $initialData;

    protected $repositoryReference = 'ezpublish.api.repository';

    /**
     * Creates a new setup factory.
     */
    public function __construct()
    {
        self::$dsn = getenv('DATABASE');
        if (!self::$dsn) {
            // use sqlite in-memory by default (does not need special handling for paratest as it's per process)
            self::$dsn = 'sqlite://:memory:';
        } elseif (getenv('TEST_TOKEN') !== false) {
            // Using paratest, assuming dsn ends with db name here...
            self::$dsn .= '_' . getenv('TEST_TOKEN');
        }

        if ($repositoryReference = getenv('REPOSITORY_SERVICE_ID')) {
            $this->repositoryReference = $repositoryReference;
        }

        self::$db = preg_replace('(^([a-z]+).*)', '\\1', self::$dsn);

        if (!isset(self::$ioRootDir)) {
            self::$ioRootDir = $this->createTemporaryDirectory();
        }
    }

    /**
     * Creates a temporary directory and returns it.
     *
     * @return string
     * @throw \RuntimeException If the root directory can't be created
     */
    private function createTemporaryDirectory()
    {
        $tmpFile = tempnam(
            sys_get_temp_dir(),
            'ez_legacy_tests_' . time()
        );
        unlink($tmpFile);

        $fs = new Filesystem();
        $fs->mkdir($tmpFile);

        $varDir = $tmpFile . '/var';
        if ($fs->exists($varDir)) {
            $fs->remove($varDir);
        }
        $fs->mkdir($varDir);

        return $tmpFile;
    }

    /**
     * Returns a configured repository for testing.
     *
     * @param bool $initializeFromScratch if the back end should be initialized
     *                                    from scratch or re-used
     *
     * @return \eZ\Publish\API\Repository\Repository
     */
    public function getRepository($initializeFromScratch = true)
    {
        if ($initializeFromScratch || !self::$schemaInitialized) {
            $this->initializeSchema();
            $this->insertData();
        }

        $this->clearInternalCaches();
        /** @var \eZ\Publish\API\Repository\Repository $repository */
        $repository = $this->getServiceContainer()->get($this->repositoryReference);

        // Set admin user as current user by default
        $repository->getPermissionResolver()->setCurrentUserReference(
            new UserReference(14)
        );

        return $repository;
    }

    /**
     * Returns a config value for $configKey.
     *
     * @param string $configKey
     *
     * @throws Exception if $configKey could not be found.
     *
     * @return mixed
     */
    public function getConfigValue($configKey)
    {
        return $this->getServiceContainer()->getParameter($configKey);
    }

    /**
     * Returns a repository specific ID manager.
     *
     * @return \eZ\Publish\API\Repository\Tests\IdManager
     */
    public function getIdManager()
    {
        return new IdManager\Php();
    }

    /**
     * Insert the database data.
     */
    public function insertData()
    {
        $data = $this->getInitialData();
        $handler = $this->getDatabaseHandler();
        $connection = $handler->getConnection();
        $dbPlatform = $connection->getDatabasePlatform();
        $this->cleanupVarDir($this->getInitialVarDir());

        foreach (array_reverse(array_keys($data)) as $table) {
            try {
                // Cleanup before inserting (using TRUNCATE for speed, however not possible to rollback)
                $connection->executeUpdate($dbPlatform->getTruncateTableSql($handler->quoteIdentifier($table)));
            } catch (DBALException | PDOException $e) {
                // Fallback to DELETE if TRUNCATE failed (because of FKs for instance)
                $connection->createQueryBuilder()->delete($table)->execute();
            }
        }

        foreach ($data as $table => $rows) {
            // Check that at least one row exists
            if (!isset($rows[0])) {
                continue;
            }

            $q = $handler->createInsertQuery();
            $q->insertInto($handler->quoteIdentifier($table));

            // Contains the bound parameters
            $values = [];

            // Binding the parameters
            foreach ($rows[0] as $col => $val) {
                $q->set(
                    $handler->quoteIdentifier($col),
                    $q->bindParam($values[$col])
                );
            }

            $stmt = $q->prepare();

            foreach ($rows as $row) {
                try {
                    // This CANNOT be replaced by:
                    // $values = $row
                    // each $values[$col] is a PHP reference which should be
                    // kept for parameters binding to work
                    foreach ($row as $col => $val) {
                        $values[$col] = $val;
                    }

                    $stmt->execute();
                } catch (Exception $e) {
                    echo "$table ( ", implode(', ', $row), " )\n";
                    throw $e;
                }
            }
        }

        $this->applyStatements($this->getPostInsertStatements());
    }

    protected function getInitialVarDir()
    {
        return __DIR__ . '/../../../../../../var';
    }

    protected function cleanupVarDir($sourceDir)
    {
        $fs = new Filesystem();
        $varDir = self::$ioRootDir . '/var';
        if ($fs->exists($varDir)) {
            $fs->remove($varDir);
        }
        $fs->mkdir($varDir);
        $fs->mirror($sourceDir, $varDir);
    }

    /**
     * CLears internal in memory caches after inserting data circumventing the
     * API.
     */
    protected function clearInternalCaches()
    {
        /** @var $handler \eZ\Publish\Core\Persistence\Legacy\Handler */
        $handler = $this->getServiceContainer()->get('ezpublish.spi.persistence.legacy');

        $contentLanguageHandler = $handler->contentLanguageHandler();
        if ($contentLanguageHandler instanceof CachingLanguageHandler) {
            $contentLanguageHandler->clearCache();
        }

        $contentTypeHandler = $handler->contentTypeHandler();
        if ($contentTypeHandler instanceof CachingContentTypeHandler) {
            $contentTypeHandler->clearCache();
        }

        /** @var $cachePool \Psr\Cache\CacheItemPoolInterface */
        $cachePool = $this->getServiceContainer()->get('ezpublish.cache_pool');

        $cachePool->clear();
    }

    /**
     * Returns statements to be executed after data insert.
     *
     * @return string[]
     */
    protected function getPostInsertStatements()
    {
        if (self::$db === 'pgsql') {
            $setvalPath = __DIR__ . '/../../../../Core/Persistence/Legacy/Tests/_fixtures/setval.pgsql.sql';

            return array_filter(preg_split('(;\\s*$)m', file_get_contents($setvalPath)));
        }

        return [];
    }

    /**
     * Returns the initial database data.
     *
     * @return array
     */
    protected function getInitialData()
    {
        if (!isset(self::$initialData)) {
            self::$initialData = include __DIR__ . '/../../../../Core/Repository/Tests/Service/Integration/Legacy/_fixtures/test_data.php';
        }

        return self::$initialData;
    }

    /**
     * Initializes the database schema.
     *
     * @throws \Doctrine\DBAL\ConnectionException
     */
    protected function initializeSchema(): void
    {
        if (!self::$schemaInitialized) {
            $schemaImporter = new LegacySchemaImporter($this->getDatabaseConnection());
            $schemaImporter->importSchema(
                dirname(__DIR__, 5) .
                '/Bundle/EzPublishCoreBundle/Resources/config/storage/legacy/schema.yaml'
            );

            self::$schemaInitialized = true;
        }
    }

    /**
     * Applies the given SQL $statements to the database in use.
     *
     * @param array $statements
     */
    protected function applyStatements(array $statements)
    {
        foreach ($statements as $statement) {
            $this->getDatabaseHandler()->exec($statement);
        }
    }

    // ************* Setup copied and refactored from common.php ************

    /**
     * Returns the database handler from the service container.
     *
     * @return \eZ\Publish\Core\Persistence\Doctrine\ConnectionHandler
     */
    protected function getDatabaseHandler()
    {
        return $this->getServiceContainer()->get('ezpublish.api.storage_engine.legacy.dbhandler');
    }

    /**
     * Returns the raw database connection from the service container.
     *
     * @return \Doctrine\DBAL\Connection
     */
    private function getDatabaseConnection(): Connection
    {
        return $this->getServiceContainer()->get('ezpublish.persistence.connection');
    }

    /**
     * Returns the service container used for initialization of the repository.
     *
     * @return \eZ\Publish\Core\Base\ServiceContainer
     */
    public function getServiceContainer()
    {
        if (!isset(self::$serviceContainer)) {
            $config = include __DIR__ . '/../../../../../../config.php';
            $installDir = $config['install_dir'];

            /** @var \Symfony\Component\DependencyInjection\ContainerBuilder $containerBuilder */
            $containerBuilder = include $config['container_builder_path'];

            /* @var \Symfony\Component\DependencyInjection\Loader\YamlFileLoader $loader */
            $loader->load('search_engines/legacy.yml');

            $loader->load('tests/integration_legacy.yml');

            $this->externalBuildContainer($containerBuilder);

            $containerBuilder->setParameter(
                'legacy_dsn',
                self::$dsn
            );

            $containerBuilder->setParameter(
                'io_root_dir',
                self::$ioRootDir . '/' . $containerBuilder->getParameter('storage_dir')
            );

            $containerBuilder->addCompilerPass(new Compiler\Search\FieldRegistryPass());

            // load overrides just before creating test Container
            $loader->load('tests/override.yml');

            self::$serviceContainer = new ServiceContainer(
                $containerBuilder,
                $installDir,
                $config['cache_dir'],
                true,
                true
            );
        }

        return self::$serviceContainer;
    }

    /**
     * This is intended to be used from external repository in order to
     * enable container customization.
     *
     * @param \Symfony\Component\DependencyInjection\ContainerBuilder $containerBuilder
     */
    protected function externalBuildContainer(ContainerBuilder $containerBuilder)

    {
        // Does nothing by default
    }

    /**
     * Get the Database name.
     *
     * @return string
     */
    public function getDB()
    {
        return self::$db;
    }
}


1			<?php
2
3			/**
4			* @copyright Copyright (C) eZ Systems AS. All rights reserved.
5			* @license For full copyright and license information view LICENSE file distributed with this source code.
6			*/
7			namespace eZ\Publish\API\Repository\Tests\SetupFactory;
8
9			use Doctrine\DBAL\Connection;
10			use Doctrine\DBAL\DBALException;
11			use Doctrine\DBAL\Driver\PDOException;
12			use Doctrine\DBAL\Schema\Schema;
13			use eZ\Publish\API\Repository\Tests\LegacySchemaImporter;
14			use eZ\Publish\Core\Base\ServiceContainer;
15			use Symfony\Component\DependencyInjection\ContainerBuilder;
16			use eZ\Publish\API\Repository\Tests\SetupFactory;
17			use eZ\Publish\API\Repository\Tests\IdManager;
18			use eZ\Publish\Core\Persistence\Legacy\Content\Type\MemoryCachingHandler as CachingContentTypeHandler;
19			use eZ\Publish\Core\Persistence\Legacy\Content\Language\CachingHandler as CachingLanguageHandler;
20			use Exception;
21			use eZ\Publish\Core\Repository\Values\User\UserReference;
22			use Symfony\Component\Filesystem\Filesystem;
23			use eZ\Publish\Core\Base\Container\Compiler;
24
25			/**
26			* A Test Factory is used to setup the infrastructure for a tests, based on a
27			* specific repository implementation to test.
28			*/
29			class Legacy extends SetupFactory
30			{
31			/**
32			* Data source name.
33			*
34			* @var string
35			*/
36			protected static $dsn;
37
38			/**
39			* Root dir for IO operations.
40			*
41			* @var string
42			*/
43			protected static $ioRootDir;
44
45			/**
46			* Database type (sqlite, mysql, ...).
47			*
48			* @var string
49			*/
50			protected static $db;
51
52			/**
53			* Service container.
54			*
55			* @var \eZ\Publish\Core\Base\ServiceContainer
56			*/
57			protected static $serviceContainer;
58
59			/**
60			* If the DB schema has already been initialized.
61			*
62			* @var bool
63			*/
64			protected static $schemaInitialized = false;
65
66			/**
67			* Initial database data.
68			*
69			* @var array
70			*/
71			protected static $initialData;
72
73			protected $repositoryReference = 'ezpublish.api.repository';
74
75			/**
76			* Creates a new setup factory.
77			*/
78			public function __construct()
79			{
80			self::$dsn = getenv('DATABASE');
81			if (!self::$dsn) {
82			// use sqlite in-memory by default (does not need special handling for paratest as it's per process)
83			self::$dsn = 'sqlite://:memory:';
84			} elseif (getenv('TEST_TOKEN') !== false) {
85			// Using paratest, assuming dsn ends with db name here...
86			self::$dsn .= '_' . getenv('TEST_TOKEN');
87			}
88
89			if ($repositoryReference = getenv('REPOSITORY_SERVICE_ID')) {
90			$this->repositoryReference = $repositoryReference;
91			}
92
93			self::$db = preg_replace('(^([a-z]+).*)', '\\1', self::$dsn);
94
95			if (!isset(self::$ioRootDir)) {
96			self::$ioRootDir = $this->createTemporaryDirectory();
97			}
98			}
99
100			/**
101			* Creates a temporary directory and returns it.
102			*
103			* @return string
104			* @throw \RuntimeException If the root directory can't be created
105			*/
106			private function createTemporaryDirectory()
107			{
108			$tmpFile = tempnam(
109			sys_get_temp_dir(),
110			'ez_legacy_tests_' . time()
111			);
112			unlink($tmpFile);
113
114			$fs = new Filesystem();
115			$fs->mkdir($tmpFile);
116
117			$varDir = $tmpFile . '/var';
118			if ($fs->exists($varDir)) {
119			$fs->remove($varDir);
120			}
121			$fs->mkdir($varDir);
122
123			return $tmpFile;
124			}
125
126			/**
127			* Returns a configured repository for testing.
128			*
129			* @param bool $initializeFromScratch if the back end should be initialized
130			* from scratch or re-used
131			*
132			* @return \eZ\Publish\API\Repository\Repository
133			*/
134			public function getRepository($initializeFromScratch = true)
135			{
136			if ($initializeFromScratch \|\| !self::$schemaInitialized) {
137			$this->initializeSchema();
138			$this->insertData();
139			}
140
141			$this->clearInternalCaches();
142			/** @var \eZ\Publish\API\Repository\Repository $repository */
143			$repository = $this->getServiceContainer()->get($this->repositoryReference);
144
145			// Set admin user as current user by default
146			$repository->getPermissionResolver()->setCurrentUserReference(
147			new UserReference(14)
148			);
149
150			return $repository;
151			}
152
153			/**
154			* Returns a config value for $configKey.
155			*
156			* @param string $configKey
157			*
158			* @throws Exception if $configKey could not be found.
159			*
160			* @return mixed
161			*/
162			public function getConfigValue($configKey)
163			{
164			return $this->getServiceContainer()->getParameter($configKey);
165			}
166
167			/**
168			* Returns a repository specific ID manager.
169			*
170			* @return \eZ\Publish\API\Repository\Tests\IdManager
171			*/
172			public function getIdManager()
173			{
174			return new IdManager\Php();
175			}
176
177			/**
178			* Insert the database data.
179			*/
180			public function insertData()
181			{
182			$data = $this->getInitialData();
183			$handler = $this->getDatabaseHandler();
184			$connection = $handler->getConnection();
185			$dbPlatform = $connection->getDatabasePlatform();
186			$this->cleanupVarDir($this->getInitialVarDir());
187
188			foreach (array_reverse(array_keys($data)) as $table) {
189			try {
190			// Cleanup before inserting (using TRUNCATE for speed, however not possible to rollback)
191			$connection->executeUpdate($dbPlatform->getTruncateTableSql($handler->quoteIdentifier($table)));
192			} catch (DBALException \| PDOException $e) {
193			// Fallback to DELETE if TRUNCATE failed (because of FKs for instance)
194			$connection->createQueryBuilder()->delete($table)->execute();
195			}
196			}
197
198			foreach ($data as $table => $rows) {
199			// Check that at least one row exists
200			if (!isset($rows[0])) {
201			continue;
202			}
203
204			$q = $handler->createInsertQuery();
205			$q->insertInto($handler->quoteIdentifier($table));
206
207			// Contains the bound parameters
208			$values = [];
209
210			// Binding the parameters
211			foreach ($rows[0] as $col => $val) {
212			$q->set(
213			$handler->quoteIdentifier($col),
214			$q->bindParam($values[$col])
215			);
216			}
217
218			$stmt = $q->prepare();
219
220			foreach ($rows as $row) {
221			try {
222			// This CANNOT be replaced by:
223			// $values = $row
224			// each $values[$col] is a PHP reference which should be
225			// kept for parameters binding to work
226			foreach ($row as $col => $val) {
227			$values[$col] = $val;
228			}
229
230			$stmt->execute();
231			} catch (Exception $e) {
232			echo "$table ( ", implode(', ', $row), " )\n";
233			throw $e;
234			}
235			}
236			}
237
238			$this->applyStatements($this->getPostInsertStatements());
239			}
240
241			protected function getInitialVarDir()
242			{
243			return __DIR__ . '/../../../../../../var';
244			}
245
246			protected function cleanupVarDir($sourceDir)
247			{
248			$fs = new Filesystem();
249			$varDir = self::$ioRootDir . '/var';
250			if ($fs->exists($varDir)) {
251			$fs->remove($varDir);
252			}
253			$fs->mkdir($varDir);
254			$fs->mirror($sourceDir, $varDir);
255			}
256
257			/**
258			* CLears internal in memory caches after inserting data circumventing the
259			* API.
260			*/
261			protected function clearInternalCaches()
262			{
263			/** @var $handler \eZ\Publish\Core\Persistence\Legacy\Handler */
264			$handler = $this->getServiceContainer()->get('ezpublish.spi.persistence.legacy');
265
266			$contentLanguageHandler = $handler->contentLanguageHandler();
267			if ($contentLanguageHandler instanceof CachingLanguageHandler) {
268			$contentLanguageHandler->clearCache();
269			}
270
271			$contentTypeHandler = $handler->contentTypeHandler();
272			if ($contentTypeHandler instanceof CachingContentTypeHandler) {
273			$contentTypeHandler->clearCache();
274			}
275
276			/** @var $cachePool \Psr\Cache\CacheItemPoolInterface */
277			$cachePool = $this->getServiceContainer()->get('ezpublish.cache_pool');
278
279			$cachePool->clear();
280			}
281
282			/**
283			* Returns statements to be executed after data insert.
284			*
285			* @return string[]
286			*/
287			protected function getPostInsertStatements()
288			{
289			if (self::$db === 'pgsql') {
290			$setvalPath = __DIR__ . '/../../../../Core/Persistence/Legacy/Tests/_fixtures/setval.pgsql.sql';
291
292			return array_filter(preg_split('(;\\s*$)m', file_get_contents($setvalPath)));
293			}
294
295			return [];
296			}
297
298			/**
299			* Returns the initial database data.
300			*
301			* @return array
302			*/
303			protected function getInitialData()
304			{
305			if (!isset(self::$initialData)) {
306			self::$initialData = include __DIR__ . '/../../../../Core/Repository/Tests/Service/Integration/Legacy/_fixtures/test_data.php';
307			}
308
309			return self::$initialData;
310			}
311
312			/**
313			* Initializes the database schema.
314			*
315			* @throws \Doctrine\DBAL\ConnectionException
316			*/
317			protected function initializeSchema(): void
318			{
319			if (!self::$schemaInitialized) {
320			$schemaImporter = new LegacySchemaImporter($this->getDatabaseConnection());
321			$schemaImporter->importSchema(
322			dirname(__DIR__, 5) .
323			'/Bundle/EzPublishCoreBundle/Resources/config/storage/legacy/schema.yaml'
324			);
325
326			self::$schemaInitialized = true;
327			}
328			}
329
330			/**
331			* Applies the given SQL $statements to the database in use.
332			*
333			* @param array $statements
334			*/
335			protected function applyStatements(array $statements)
336			{
337			foreach ($statements as $statement) {
338			$this->getDatabaseHandler()->exec($statement);
339			}
340			}
341
342			// *********** Setup copied and refactored from common.php **********
343
344			/**
345			* Returns the database handler from the service container.
346			*
347			* @return \eZ\Publish\Core\Persistence\Doctrine\ConnectionHandler
348			*/
349			protected function getDatabaseHandler()
350			{
351			return $this->getServiceContainer()->get('ezpublish.api.storage_engine.legacy.dbhandler');
352			}
353
354			/**
355			* Returns the raw database connection from the service container.
356			*
357			* @return \Doctrine\DBAL\Connection
358			*/
359			private function getDatabaseConnection(): Connection
360			{
361			return $this->getServiceContainer()->get('ezpublish.persistence.connection');
362			}
363
364			/**
365			* Returns the service container used for initialization of the repository.
366			*
367			* @return \eZ\Publish\Core\Base\ServiceContainer
368			*/
369			public function getServiceContainer()
370			{
371			if (!isset(self::$serviceContainer)) {
372			$config = include __DIR__ . '/../../../../../../config.php';
373			$installDir = $config['install_dir'];
374
375			/** @var \Symfony\Component\DependencyInjection\ContainerBuilder $containerBuilder */
376			$containerBuilder = include $config['container_builder_path'];
377
378			/* @var \Symfony\Component\DependencyInjection\Loader\YamlFileLoader $loader */
379			$loader->load('search_engines/legacy.yml');
			0 ignored issues – show Bug introduced 2017-04-18 15:26 UTC by Report Bug Copy Issue Report The variable `$loader` does not exist. Did you forget to declare it? This check marks access to variables or properties that have not been declared yet. While PHP has no explicit notion of declaring a variable, accessing it before a value is assigned to it is most likely a bug. Loading history...
380			$loader->load('tests/integration_legacy.yml');
381
382			$this->externalBuildContainer($containerBuilder);
383
384			$containerBuilder->setParameter(
385			'legacy_dsn',
386			self::$dsn
387			);
388
389			$containerBuilder->setParameter(
390			'io_root_dir',
391			self::$ioRootDir . '/' . $containerBuilder->getParameter('storage_dir')
392			);
393
394			$containerBuilder->addCompilerPass(new Compiler\Search\FieldRegistryPass());
395
396			// load overrides just before creating test Container
397			$loader->load('tests/override.yml');
398
399			self::$serviceContainer = new ServiceContainer(
400			$containerBuilder,
401			$installDir,
402			$config['cache_dir'],
403			true,
404			true
405			);
406			}
407
408			return self::$serviceContainer;
409			}
410
411			/**
412			* This is intended to be used from external repository in order to
413			* enable container customization.
414			*
415			* @param \Symfony\Component\DependencyInjection\ContainerBuilder $containerBuilder
416			*/
417			protected function externalBuildContainer(ContainerBuilder $containerBuilder)
			0 ignored issues – show Unused Code introduced 2017-07-31 12:38 UTC by Report Bug Copy Issue Report The parameter `$containerBuilder` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
418			{
419			// Does nothing by default
420			}
421
422			/**
423			* Get the Database name.
424			*
425			* @return string
426			*/
427			public function getDB()
428			{
429			return self::$db;
430			}
431			}
432

ezsystems / ezpublish-kernel

Push — ezp-31420-merge-up ( ec14fb...141a64 )

Legacy::insertData() B

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like