Bdf\Prime\Schema\SchemaManager

Complexity

Total Complexity

35

Size/Duplication

Total Lines	267
Duplicated Lines	0 %

Test Coverage

Coverage

68.75%

Importance

Changes	1
Bugs	0	Features	0

18 Methods

Rating	Name	Duplication	Size	Complexity
A	schema()	0	18	3
A	dropDatabase()	0	8	2
A	drop()	0	8	2
A	rename()	0	11	2
A	hasTable()	0	6	2
A	createDatabase()	0	8	2
A	toSql()	0	3	1
A	loadTable()	0	22	3
A	getDoctrineManager()	0	3	1
A	pending()	0	3	1
A	truncate()	0	8	2
A	loadSchema()	0	3	1
A	diff()	0	8	1
A	getDatabases()	0	6	2
A	flush()	0	12	2
A	clear()	0	5	1
A	hasDatabase()	0	9	2
A	push()	0	15	5

<?php

namespace Bdf\Prime\Schema;

use Bdf\Prime\Exception\DBALException;
use Bdf\Prime\Schema\Adapter\Doctrine\DoctrineTable as PrimeTableAdapter;
use Bdf\Prime\Schema\Transformer\Doctrine\TableTransformer;
use Doctrine\DBAL\DBALException as DoctrineDBALException;
use Doctrine\DBAL\Schema\Schema as DoctrineSchema;
use Doctrine\DBAL\Schema\SchemaConfig;
use Doctrine\DBAL\Schema\SchemaDiff as DoctrineSchemaDiff;
use Doctrine\DBAL\Schema\TableDiff as DoctrineTableDiff;
use Doctrine\DBAL\Schema\Table as DoctrineTable;

/**
 * SchemaManager using doctrine schemas
 */
class SchemaManager extends AbstractSchemaManager
{
    /**
     * Queries to execute
     * 
     * @var array
     */
    private $queries = [];

    
    /**
     * Get the doctrine schema manager
     * 
     * @return \Doctrine\DBAL\Schema\AbstractSchemaManager
     */
    public function getDoctrineManager()

Expected 1 blank line before function; 2 found

    {
        return $this->connection->getSchemaManager();

The method getSchemaManager() does not exist on Bdf\Prime\Connection\ConnectionInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Bdf\Prime\Connection\ConnectionInterface.

    }
    
    /**
     * Get the queries to execute
     * 
     * @return array
     */
    public function toSql()
    {
        return $this->queries;
    }

    /**
     * {@inheritdoc}
     */
    public function pending()
    {
        return $this->queries;
    }

    /**
     * {@inheritdoc}
     */
    public function clear()
    {
        $this->queries = [];
        
        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function flush()
    {
        $lastResult = false;
        $queries = $this->queries;
        
        $this->clear();
        
        foreach ($queries as $query) {
            $lastResult = $this->connection->exec($query);

The method exec() does not exist on Bdf\Prime\Connection\ConnectionInterface. Did you maybe mean execute()?

        }
        
        return $lastResult;
    }

    /**

Parameter $tables should have a doc-comment as per coding-style.

     * {@inheritdoc}
     */
    public function schema($tables = [])
    {
        if (!is_array($tables)) {
            $tables = [$tables];
        }

        $tables = array_map(function ($table) {
            if ($table instanceof TableInterface) {
                return (new TableTransformer($table, $this->platform))->toDoctrine();
            }

            return $table;
        }, $tables);

        $config = new SchemaConfig();
        $config->setName($this->connection->getDatabase());

        return new DoctrineSchema($tables, [], $config);
    }

    /**
     * {@inheritdoc}
     */
    public function loadSchema()
    {
        return $this->getDoctrineManager()->createSchema();
    }

    /**

Parameter $database should have a doc-comment as per coding-style.

     * {@inheritdoc}
     */

Missing @throws tag in function comment

    public function hasDatabase($database)
    {
        try {
            $databases = $this->getDoctrineManager()->listDatabases($database);

The call to Doctrine\DBAL\Schema\AbstractSchemaManager::listDatabases() has too many arguments starting with $database.

        } catch (DoctrineDBALException $e) {
            throw new DBALException($e->getMessage(), $e->getCode(), $e);
        }

        return in_array(strtolower($database), array_map('strtolower', $databases));
    }

    /**
     * {@inheritdoc}
     */

Missing @throws tag in function comment

    public function getDatabases()
    {
        try {
            return $this->getDoctrineManager()->listDatabases();
        } catch (DoctrineDBALException $e) {
            throw new DBALException($e->getMessage(), $e->getCode(), $e);
        }
    }

    /**

Parameter $database should have a doc-comment as per coding-style.

     * {@inheritdoc}
     */

Missing @throws tag in function comment

    public function createDatabase($database)
    {
        try {
            return $this->push(
                $this->platform->grammar()->getCreateDatabaseSQL($database)
            );
        } catch (DoctrineDBALException $e) {
            throw new DBALException($e->getMessage(), $e->getCode(), $e);
        }
    }

    /**

Parameter $database should have a doc-comment as per coding-style.

     * {@inheritdoc}
     */

Missing @throws tag in function comment

    public function dropDatabase($database)
    {
        try {
            return $this->push(
                $this->platform->grammar()->getDropDatabaseSQL($database)
            );
        } catch (DoctrineDBALException $e) {
            throw new DBALException($e->getMessage(), $e->getCode(), $e);
        }
    }

    /**

Parameter $tableName should have a doc-comment as per coding-style.

     * {@inheritdoc}
     */

Missing @throws tag in function comment

    public function hasTable($tableName)
    {
        try {
            return $this->getDoctrineManager()->tablesExist($tableName);
        } catch (DoctrineDBALException $e) {
            throw new DBALException($e->getMessage(), $e->getCode(), $e);
        }
    }

    /**

Parameter $tableName should have a doc-comment as per coding-style.

     * {@inheritdoc}
     */

Missing @throws tag in function comment

    public function loadTable($tableName)
    {
        try {
            $manager = $this->getDoctrineManager();

            $foreignKeys = [];

            if ($this->platform->grammar()->supportsForeignKeyConstraints()) {
                $foreignKeys = $manager->listTableForeignKeys($tableName);
            }

            return new PrimeTableAdapter(
                new DoctrineTable(
                    $tableName,
                    $manager->listTableColumns($tableName),
                    $manager->listTableIndexes($tableName),
                    $foreignKeys
                ),
                $this->connection->platform()->types()
            );
        } catch (DoctrineDBALException $e) {
            throw new DBALException($e->getMessage(), $e->getCode(), $e);
        }

End comment for long condition not found; expected "//end try"

    }

    /**

Parameter $tableName should have a doc-comment as per coding-style.

     * {@inheritdoc}
     */

Missing @throws tag in function comment

    public function drop($tableName)
    {
        try {
            return $this->push(
                $this->platform->grammar()->getDropTableSQL($tableName)
            );
        } catch (DoctrineDBALException $e) {
            throw new DBALException($e->getMessage(), $e->getCode(), $e);
        }
    }

    /**

Parameter $tableName should have a doc-comment as per coding-style.

Parameter $cascade should have a doc-comment as per coding-style.

     * {@inheritdoc}
     */

Missing @throws tag in function comment

    public function truncate($tableName, $cascade = false)
    {
        try {
            return $this->push(
                $this->platform->grammar()->getTruncateTableSQL($tableName, $cascade)
            );
        } catch (DoctrineDBALException $e) {
            throw new DBALException($e->getMessage(), $e->getCode(), $e);
        }
    }

    /**

Parameter $newTable should have a doc-comment as per coding-style.

Parameter $oldTable should have a doc-comment as per coding-style.

     * {@inheritdoc}
     */
    public function diff(TableInterface $newTable, TableInterface $oldTable)
    {
        $comparator = new Comparator();

The class Bdf\Prime\Schema\Comparator has been deprecated: since 1.3 Use Prime comparators instead

        $comparator->setListDropColumn($this->useDrop);

        return $comparator->compare(
            $this->schema($oldTable),
            $this->schema($newTable)
        );
    }

    /**

Parameter $from should have a doc-comment as per coding-style.

Parameter $to should have a doc-comment as per coding-style.

     * {@inheritdoc}
     */

Missing @throws tag in function comment

    public function rename($from, $to)
    {
        $diff = new DoctrineTableDiff($from);
        $diff->newName = $to;

        try {
            return $this->push(
                $this->platform->grammar()->getAlterTableSQL($diff)
            );
        } catch (DoctrineDBALException $e) {
            throw new DBALException($e->getMessage(), $e->getCode(), $e);
        }
    }

    /**

Parameter $queries should have a doc-comment as per coding-style.

     * {@inheritdoc}
     */
    public function push($queries)
    {
        if ($queries instanceof DoctrineSchema || $queries instanceof DoctrineSchemaDiff) {
            $queries = $queries->toSql($this->platform->grammar());
        }

        foreach ((array)$queries as $query) {

Expected 1 space(s) after cast statement; 0 found

            $this->queries[] = $query;
        }

        if ($this->autoFlush) {
            $this->flush();
        }

        return $this;
    }
}