ManagesTransactions::beginTransaction() - Code Metrics - Inspection of "PHPStan level 6" - LaravelFreelancerNL/laravel-arangodb - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — refactor/improve-static-analys... ( efcf20...37f12c )

by Bas

created 2023-12-31 11:43 UTC

ManagesTransactions::beginTransaction() A

↳ Parent: ManagesTransactions

Complexity

Conditions	1
Paths	1

Size

Total Lines	7
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	4
CRAP Score	1

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
eloc	3
c	1
b	0
f	0
dl	0
loc	7
ccs	4
cts	4
cp	1
rs	10
cc	1
nc	1
nop	1
crap	1

<?php

declare(strict_types=1);

namespace LaravelFreelancerNL\Aranguent\Concerns;

use Closure;
use LaravelFreelancerNL\Aranguent\Exceptions\NoArangoClientException;
use Throwable;

trait ManagesTransactions
{
    /**
     * Execute a Closure within a transaction.
     *
     * @param \Closure $callback
     * @param  int  $attempts
     * @param  array<mixed> $collections
     *
     * @return mixed
     *
     * @throws \Throwable
     */
    public function transaction(Closure $callback, $attempts = 1, array $collections = [])
    {
        for ($currentAttempt = 1; $currentAttempt <= $attempts; $currentAttempt++) {
            $this->beginTransaction($collections);

            // We'll simply execute the given callback within a try / catch block and if we
            // catch any exception we can rollback this transaction so that none of this
            // gets actually persisted to a database or stored in a permanent fashion.
            try {
                $callbackResult = $callback($this);
            } catch (Throwable $e) {
                // If we catch an exception we'll rollback this transaction and try again if we
                // are not out of attempts. If we are out of attempts we will just throw the
                // exception back out and let the developer handle an uncaught exceptions.

                $this->handleTransactionException(
                       handleTransactionException(
                    $e,
                    $currentAttempt,
                    $attempts
                );

                continue;
            }

            try {
                if ($this->transactions == 1) {
                    $this->commit();
                }

                $this->transactions = max(0, $this->transactions - 1);

            } catch (Throwable $e) {
                $this->handleCommitTransactionException(
                       handleCommitTransactionException(
                    $e,
                    $currentAttempt,
                    $attempts
                );

                continue;
            }

            $this->fireConnectionEvent('committed');
                   fireConnectionEvent('committed');

            return $callbackResult;
        }
    }

    /**
     * Start a new database transaction.
     *
     * @param  array<string, array<string>>  $collections
     *
     * @throws Throwable
     */
    public function beginTransaction(array $collections = []): void
    {
        $this->createTransaction($collections);

        $this->transactions++;

        $this->fireConnectionEvent('beganTransaction');
    }

    /**
     * Create a transaction within the database.
     *
     * @param  array<string, array<string>>  $collections
     *
     * @throws Throwable
     */
    protected function createTransaction(array $collections = []): void
    {
        if ($this->transactions == 0) {
            $this->reconnectIfMissingConnection();
                   reconnectIfMissingConnection();

            try {
                if ($this->arangoClient === null) {
                    throw new NoArangoClientException();
                }
                $this->arangoClient->begin($collections);
            } catch (Throwable $e) {
                $this->handleBeginTransactionException($e);
                       handleBeginTransactionException($e);
            }
        }
    }

    /**
     * Commit the active database transaction.
     *
     * @return void
     *
     * @throws Throwable
     */
    public function commit()
    {
        if ($this->arangoClient === null) {
            throw new NoArangoClientException();
        }

        if ($this->transactions == 1) {
            $this->arangoClient->commit();
        }

        $this->transactions = max(0, $this->transactions - 1);


        $this->fireConnectionEvent('committed');
    }

    /**
     * Rollback the active database transaction.
     *
     * @param  int|null  $toLevel
     * @return void
     *
     * @throws \Throwable
     */
    public function rollBack($toLevel = null)
    {
        // We allow developers to rollback to a certain transaction level. We will verify
        // that this given transaction level is valid before attempting to rollback to
        // that level. If it's not we will just return out and not attempt anything.
        $toLevel = is_null($toLevel)
            ? $this->transactions - 1
            : $toLevel;

        if ($toLevel < 0 || $toLevel >= $this->transactions) {
            return;
        }

        // Next, we will actually perform this rollback within this database and fire the
        // rollback event. We will also set the current transaction level to the given
        // level that was passed into this method so it will be right from here out.
        try {
            $this->performRollBack($toLevel);
        } catch (Throwable $e) {
            $this->handleRollBackException($e);
                   handleRollBackException($e);
        }

        $this->transactions = $toLevel;


        $this->fireConnectionEvent('rollingBack');
    }

    /**
     * Perform a rollback within the database.
     *
     * @param  int  $toLevel
     * @return void
     *
     * @throws Throwable
     */
    protected function performRollBack($toLevel)
    {
        if ($this->arangoClient === null) {
            throw new NoArangoClientException();
        }

        if ($toLevel == 0) {
            $this->arangoClient->abort();
        }
    }
}


LaravelFreelancerNL / laravel-arangodb

Push — refactor/improve-static-analys... ( efcf20...37f12c )

ManagesTransactions::beginTransaction() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like