Bdf\Prime\Schema\AbstractSchemaManager

Complexity

Total Complexity

16

Size/Duplication

Total Lines	185
Duplicated Lines	0 %

Test Coverage

Coverage

95.08%

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	transaction()	0	30	4
A	setConnection()	0	6	1
A	__construct()	0	3	1
A	table()	0	10	1
A	getUseDrop()	0	3	1
A	getConnection()	0	3	1
A	change()	0	14	1
A	add()	0	9	2
A	isBuffered()	0	3	1
A	useDrop()	0	5	1
A	simulate()	0	10	2

<?php

namespace Bdf\Prime\Schema;

use BadMethodCallException;
use Bdf\Prime\Connection\ConnectionInterface;
use Bdf\Prime\Connection\TransactionManagerInterface;
use Bdf\Prime\Exception\DBALException;
use Bdf\Prime\Exception\PrimeException;
use Bdf\Prime\Platform\PlatformInterface;
use Bdf\Prime\Schema\Builder\TableBuilder;
use Bdf\Prime\Schema\Builder\TypesHelperTableBuilder;
use Doctrine\DBAL\DBALException as DoctrineDBALException;

/**
 * Class AbstractSchemaManager
 *
 * @template C as ConnectionInterface
 * @implements SchemaManagerInterface<C>
 */
abstract class AbstractSchemaManager implements SchemaManagerInterface
{
    /**
     * The database connection instance.
     *
     * @var C
     */
    protected $connection;

    /**
     * The connection platform.
     *
     * @var PlatformInterface
     */
    protected $platform;

    /**
     * The use drop flag. Allows builder to use drop command on diff
     *
     * @var bool

Expected "boolean" but found "bool" for @var tag in member variable comment

     */
    protected $useDrop = true;

    /**
     * The auto flush flag. Allows builder execute query
     *
     * @var bool

Expected "boolean" but found "bool" for @var tag in member variable comment

     * @internal

@internal tag is not allowed in member variable comment

     */
    protected $autoFlush = true;


    /**
     * Create a new schema builder.
     *
     * @param C $connection
     * @throws PrimeException

Tag @throws cannot be grouped with parameter tags in a doc comment

     */
    public function __construct(ConnectionInterface $connection)

Expected 1 blank line before function; 2 found

    {
        $this->setConnection($connection);
    }

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

    /**

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

     * {@inheritdoc}
     */
    public function setConnection(ConnectionInterface $connection)
    {
        $this->connection = $connection;

It seems like $connection of type Bdf\Prime\Connection\ConnectionInterface is incompatible with the declared type Bdf\Prime\Schema\C of property $connection.

        $this->platform   = $connection->platform();

        return $this;
    }

    /**

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

     * {@inheritdoc}
     */
    public function useDrop($flag = true)
    {
        $this->useDrop = $flag;

        return $this;
    }

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

    /**

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

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

     * {@inheritdoc}
     */
    public function table($tableName, callable $callback)
    {
        $table = new TypesHelperTableBuilder(
            new TableBuilder($tableName),
            $this->platform->types()
        );
        
        $callback($table);

        return $this->add($table->build());

The expression return $this->add($table->build()) returns the type Bdf\Prime\Schema\Manager\QueryManagerInterface which is incompatible with the return type mandated by Bdf\Prime\Schema\Manager\TableManagerInterface::table() of Bdf\Prime\Schema\Manager\TableManagerInterface.

    }

    /**

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

     * {@inheritdoc}
     */
    public function add(TableInterface $table)
    {
        if ($this->hasTable($table->name())) {
            return $this->push(

The expression return $this->push($this->diff($table, $this->loadTable($table->name()))) returns the type Bdf\Prime\Schema\Manager\QueryManagerInterface which is incompatible with the return type mandated by Bdf\Prime\Schema\Manager\TableManagerInterface::add() of Bdf\Prime\Schema\Manager\TableManagerInterface.

                $this->diff($table, $this->loadTable($table->name()))
            );
        }

        return $this->push($this->schema($table));

The expression return $this->push($this->schema($table)) returns the type Bdf\Prime\Schema\Manager\QueryManagerInterface which is incompatible with the return type mandated by Bdf\Prime\Schema\Manager\TableManagerInterface::add() of Bdf\Prime\Schema\Manager\TableManagerInterface.

The function Bdf\Prime\Schema\SchemaManagerInterface::schema() has been deprecated: since 1.3 Doctrine schema should be used only internally

    }

    /**

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

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

     * {@inheritdoc}
     */
    public function change($tableName, callable $callback)
    {
        $table = $this->loadTable($tableName);
        $builder = TableBuilder::fromTable($table);

        $callback(
            new TypesHelperTableBuilder(
                $builder,
                $this->platform->types()
            )
        );

        return $this->push(

The expression return $this->push($this->diff($builder->build(), $table)) returns the type Bdf\Prime\Schema\Manager\QueryManagerInterface which is incompatible with the return type mandated by Bdf\Prime\Schema\Manager\TableManagerInterface::change() of Bdf\Prime\Schema\Manager\TableManagerInterface.

            $this->diff($builder->build(), $table)
        );
    }

    /**

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

     * {@inheritdoc}
     */
    public function simulate(callable $operations = null)
    {
        $newSchema = clone $this;
        $newSchema->autoFlush = false;

        if ($operations !== null) {
            $operations($newSchema);
        }

        return $newSchema;
    }

    /**

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

     * {@inheritdoc}
     */

Missing @throws tag in function comment

    public function transaction(callable $operations)
    {
        $last = $this->autoFlush;
        $this->autoFlush = false;

        if (!$this->connection instanceof TransactionManagerInterface) {
            throw new BadMethodCallException('The connection '.$this->connection->getName().' do not handle transactions');
        }

        try {
            $operations($this);

            $this->connection->beginTransaction();
            $this->flush();
            $this->connection->commit();
        } catch (DoctrineDBALException $e) {
            $this->connection->rollBack();

            /** @psalm-suppress InvalidScalarArgument */

The open comment tag must be the only content on the line

The close comment tag must be the only content on the line

Block comments must be started with /*

Inline doc block comments are not allowed; use "/* Comment */" or "// Comment" instead

            throw new DBALException($e->getMessage(), $e->getCode(), $e);
        } catch (\Exception $e) {
            $this->connection->rollBack();

            throw $e;
        } finally {
            $this->autoFlush = $last;
            $this->clear();
        }

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function isBuffered()
    {
        return !$this->autoFlush;
    }
}