Legacy::insertData() - Code Metrics - Inspection of "EZP-29201: Added additional index/foreign keys to..." - ezsystems/ezpublish-kernel - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 2c0170...b4f3d9 )

by Łukasz

created 2018-06-04 11:07 UTC

Legacy::insertData() C

↳ Parent: Legacy

Complexity

Conditions	9
Paths	42

Size

Total Lines	66
Code Lines	35

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	9
eloc	35
nc	42
nop	0
dl	0
loc	66
rs	6.4099
c	0
b	0
f	0

How to fix Long Method

<?php

/**
 * File containing the Test Setup Factory base class.
 *
 * @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\DBALException;
use Doctrine\DBAL\Driver\PDOException;
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) {
            self::$dsn = 'sqlite://:memory:';
        }

        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();
        $repository = $this->getServiceContainer()->get($this->repositoryReference);

        // Set admin user as current user by default
        $repository->setCurrentUser(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());

        // @todo FIXME: Needs to be in fixture
        $data['ezcontentobject_trash'] = array();
        $data['ezurlwildcard'] = array();
        $data['ezmedia'] = array();
        $data['ezkeyword'] = array();

        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 = array();

            // 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 array();
    }

    /**
     * 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/clean_ezdemo_47_dump.php';
            // self::$initialData = include __DIR__ . '/../../../../Core/Repository/Tests/Service/Legacy/_fixtures/full_dump.php';
        }

        return self::$initialData;
    }

    /**
     * Initializes the database schema.
     */
    protected function initializeSchema()
    {
        if (!self::$schemaInitialized) {
            $statements = $this->getSchemaStatements();

            $this->applyStatements($statements);

            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 schema as an array of SQL statements.
     *
     * @return string[]
     */
    protected function getSchemaStatements()
    {
        $schemaPath = __DIR__ . '/../../../../Core/Persistence/Legacy/Tests/_fixtures/schema.' . self::$db . '.sql';

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

    /**
     * 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 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\SearchEngineSignalSlotPass('legacy'));
            $containerBuilder->addCompilerPass(new Compiler\Search\FieldRegistryPass());

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

ezsystems / ezpublish-kernel

Push — master ( 2c0170...b4f3d9 )

Legacy::insertData() C

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like