AbstractSchemaManager::transaction() - Code Metrics - Inspection of "Refactor exception system" - b2pweb/bdf-prime - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#13)

by Vincent

created 2020-11-24 10:04 UTC

AbstractSchemaManager::transaction() A

↳ Parent: AbstractSchemaManager

Complexity

Conditions	3
Paths	21

Size

Total Lines	25
Code Lines	17

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	15
CRAP Score	3.0146

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
eloc	17
c	1
b	0
f	0
dl	0
loc	25
ccs	15
cts	17
cp	0.8824
rs	9.7
cc	3
nc	21
nop	1
crap	3.0146

<?php

namespace Bdf\Prime\Schema;

use Bdf\Prime\Connection\ConnectionInterface;
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
 */
abstract class AbstractSchemaManager implements SchemaManagerInterface
{
    /**
     * The database connection instance.
     *
     * @var ConnectionInterface
     */
    protected $connection;

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

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

     */
    protected $useDrop = true;

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

     * @internal

     */
    protected $autoFlush = true;


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

     */
    public function __construct(ConnectionInterface $connection)

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

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

    /**

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

        return $this;
    }

    /**

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

        return $this;
    }

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

    /**

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

        return $this->add($table->build());
interface HasName {
    /** @return string */
    public function getName();
}

class Name {
    public $name;
}

class User implements HasName {
    /** @return string|Name */
    public function getName() {
        return new Name('foo'); // This is a violation of the ``HasName`` interface
                                // which only allows a string value to be returned.
    }
}
    }

    /**

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

class Name {
    public $name;
}

class User implements HasName {
    /** @return string|Name */
    public function getName() {
        return new Name('foo'); // This is a violation of the ``HasName`` interface
                                // which only allows a string value to be returned.
    }
}
                $this->diff($table, $this->loadTable($table->name()))
            );
        }

        return $this->push($this->schema($table));
        return $this->push(/** @scrutinizer ignore-deprecated */ $this->schema($table));
    }

    /**

     * {@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(
interface HasName {
    /** @return string */
    public function getName();
}

class Name {
    public $name;
}

class User implements HasName {
    /** @return string|Name */
    public function getName() {
        return new Name('foo'); // This is a violation of the ``HasName`` interface
                                // which only allows a string value to be returned.
    }
}
            $this->diff($builder->build(), $table)
        );
    }

    /**

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

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

        return $newSchema;
    }

    /**

     * {@inheritdoc}
     */

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

        try {
            $operations($this);

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

            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;
    }
}


b2pweb / bdf-prime

Pull Request — master (#13)

AbstractSchemaManager::transaction() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like