Transaction::run() - Code Metrics - Inspection of "cs" - spiral/components - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Branch — feature/pre-split (745f0c)

by Anton

created 2017-01-13 17:32 UTC

Transaction::run() C

↳ Parent: Transaction

Complexity

Conditions	10
Paths	80

Size

Total Lines	50
Code Lines	24

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	10
eloc	24
nc	80
nop	0
dl	0
loc	50
rs	5.7647
c	0
b	0
f	0

How to fix Complexity

<?php
/**
 * components
 *
 * @author    Wolfy-J
 */
namespace Spiral\ORM;

use Spiral\Database\Entities\Driver;
use Spiral\ORM\Exceptions\RecordException;

/**
 * Singular ORM transaction with ability to automatically open transaction for all involved
 * drivers.
 *
 * Drivers will be automatically fetched from commands.
 */
class Transaction implements TransactionInterface
{
    /**
     * @var CommandInterface[]
     */
    private $commands = [];

    /**
     * Store entity information (update or insert).
     *
     * @param RecordInterface $record
     *
     * @throws RecordException
     */
    public function store(RecordInterface $record)
    {
        $this->addCommand($record->queueStore());
    }

    /**
     * Delete entity from database.
     *
     * @param RecordInterface $record
     *
     * @throws RecordException
     */
    public function delete(RecordInterface $record)
    {
        $this->addCommand($record->queueDelete());
    }

    /**
     * {@inheritdoc}
     */
    final public function addCommand(CommandInterface $command)
    {
        $this->commands[] = $command;
    }

    /**
     * @return \Generator
     */
    final public function getCommands()
    {
        foreach ($this->commands as $command) {
            if ($command instanceof TransactionInterface) {
                yield from $command->getCommands();
            }

            yield $command;
        }
    }

    /**
     * {@inheritdoc}
     *
     * Executing transaction.
     */
    public function run()
    {
        /**
         * @var Driver[]           $drivers
         * @var CommandInterface[] $executedCommands
         */
        $drivers = [];
        $executedCommands = [];

        try {
            foreach ($this->getCommands() as $command) {
                if ($command instanceof TransactionInterface) {
                    //All transaction commands are flatten (see getCommands() method)
                    continue;
                }

                if ($command instanceof SQLCommandInterface) {
                    $driver = $command->getDriver();

                    if (in_array($driver, $drivers)) {
                        //Command requires DBAL driver to open transaction
                        $drivers[] = $driver;
                        $driver->beginTransaction();
                    }
                }

                //Execute command
                $command->execute();
                $executedCommands[] = $command;
            }
        } catch (\Throwable $e) {
            foreach (array_reverse($drivers) as $driver) {
                $driver->rollbackTransaction();
            }

            foreach (array_reverse($executedCommands) as $command) {
                $command->rollBack();
            }

            throw $e;
        }

        foreach ($drivers as $driver) {
            $driver->commitTransaction();
        }

        foreach ($executedCommands as $command) {
            $command->complete();
        }
    }
}

1			<?php
2			/**
3			* components
4			*
5			* @author Wolfy-J
6			*/
7			namespace Spiral\ORM;
8
9			use Spiral\Database\Entities\Driver;
10			use Spiral\ORM\Exceptions\RecordException;
11
12			/**
13			* Singular ORM transaction with ability to automatically open transaction for all involved
14			* drivers.
15			*
16			* Drivers will be automatically fetched from commands.
17			*/
18			class Transaction implements TransactionInterface
19			{
20			/**
21			* @var CommandInterface[]
22			*/
23			private $commands = [];
24
25			/**
26			* Store entity information (update or insert).
27			*
28			* @param RecordInterface $record
29			*
30			* @throws RecordException
31			*/
32			public function store(RecordInterface $record)
33			{
34			$this->addCommand($record->queueStore());
35			}
36
37			/**
38			* Delete entity from database.
39			*
40			* @param RecordInterface $record
41			*
42			* @throws RecordException
43			*/
44			public function delete(RecordInterface $record)
45			{
46			$this->addCommand($record->queueDelete());
47			}
48
49			/**
50			* {@inheritdoc}
51			*/
52			final public function addCommand(CommandInterface $command)
53			{
54			$this->commands[] = $command;
55			}
56
57			/**
58			* @return \Generator
59			*/
60			final public function getCommands()
61			{
62			foreach ($this->commands as $command) {
63			if ($command instanceof TransactionInterface) {
64			yield from $command->getCommands();
65			}
66
67			yield $command;
68			}
69			}
70
71			/**
72			* {@inheritdoc}
73			*
74			* Executing transaction.
75			*/
76			public function run()
77			{
78			/**
79			* @var Driver[] $drivers
80			* @var CommandInterface[] $executedCommands
81			*/
82			$drivers = [];
83			$executedCommands = [];
84
85			try {
86			foreach ($this->getCommands() as $command) {
87			if ($command instanceof TransactionInterface) {
88			//All transaction commands are flatten (see getCommands() method)
89			continue;
90			}
91
92			if ($command instanceof SQLCommandInterface) {
93			$driver = $command->getDriver();
94
95			if (in_array($driver, $drivers)) {
96			//Command requires DBAL driver to open transaction
97			$drivers[] = $driver;
98			$driver->beginTransaction();
99			}
100			}
101
102			//Execute command
103			$command->execute();
104			$executedCommands[] = $command;
105			}
106			} catch (\Throwable $e) {
107			foreach (array_reverse($drivers) as $driver) {
108			$driver->rollbackTransaction();
109			}
110
111			foreach (array_reverse($executedCommands) as $command) {
112			$command->rollBack();
113			}
114
115			throw $e;
116			}
117
118			foreach ($drivers as $driver) {
119			$driver->commitTransaction();
120			}
121
122			foreach ($executedCommands as $command) {
123			$command->complete();
124			}
125			}
126			}

spiral / components

Branch — feature/pre-split (745f0c)

Transaction::run() C

Complexity

Size

Duplication

Importance

How to fix Complexity

Long Method

Duplication Side-by-Side

Filter issues like