Builder::handleExceptionsAsQueryExceptions() - 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

Builder::handleExceptionsAsQueryExceptions() A

↳ Parent: Builder

Complexity

Conditions	2
Paths	2

Size

Total Lines	6
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	4
CRAP Score	2

Importance

Changes

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

<?php

declare(strict_types=1);

namespace LaravelFreelancerNL\Aranguent\Schema;

use ArangoClient\Exceptions\ArangoException;
use ArangoClient\Schema\SchemaManager;
use Closure;
use Illuminate\Support\Facades\Log;
use Illuminate\Support\Fluent;
use LaravelFreelancerNL\Aranguent\Connection;
use LaravelFreelancerNL\Aranguent\Exceptions\QueryException;
use LaravelFreelancerNL\Aranguent\Schema\Concerns\HandlesAnalyzers;
use LaravelFreelancerNL\Aranguent\Schema\Concerns\HandlesViews;
use LaravelFreelancerNL\Aranguent\Schema\Concerns\UsesBlueprints;

class Builder extends \Illuminate\Database\Schema\Builder
{
    use HandlesAnalyzers;
    use HandlesViews;

    use UsesBlueprints;

    /**
     * The database connection instance.
     *
     * @var Connection
     */
    protected $connection;

    protected SchemaManager $schemaManager;

    /**
     * The schema grammar instance.
     *
     * @var Grammar
     */
    protected $grammar;

    /**
     * Create a new database Schema manager.
     *
     * Builder constructor.
     */
    public function __construct(Connection $connection)
    {
        $this->connection = $connection;

        $this->grammar = $connection->getSchemaGrammar();

        $this->schemaManager = $connection->getArangoClient()->schema();
    }

    /**
     * Determine if the given table exists.
     *
     * @param  string  $table
     * @return bool
     */
    public function hasTable($table)
    {
        return $this->handleExceptionsAsQueryExceptions(function () use ($table) {
            return $this->schemaManager->hasCollection($table);
        });
    }

    /**
     * @throws ArangoException
     */
    public function dropIfExists($table): void
    {
        $tableExists = $this->hasTable($table);
        if ($tableExists) {
            $this->drop($table);
        }
    }

    /**
     * Get all the tables for the database; excluding ArangoDB system collections
     *
     * @return array<mixed>
     *
     * @throws ArangoException
     */
    public function getAllTables(): array
    {
        return $this->schemaManager->getCollections(true);
    }

    /**
     * Rename a table (collection).
     *
     * @param  string  $from
     * @param  string  $to
     *
     * @throws ArangoException
     */
    public function rename($from, $to): bool
    {
        return (bool) $this->schemaManager->renameCollection($from, $to);
    }

    /**
     * Drop a table (collection) from the schema.
     *
     * @throws ArangoException
     */
    public function drop($table)
    {
        $this->schemaManager->deleteCollection($table);
    }

    /**
     * Drop all tables (collections) from the schema.
     *
     * @throws ArangoException
     */
    public function dropAllTables(): void
    {
        $collections = $this->getAllTables();

        foreach ($collections as $name) {
            $this->schemaManager->deleteCollection($name->name);
        }
    }

    /**
     * Determine if the given table has a given column.
     *
     * @param  string  $table
     * @param  string  $column
     * @return bool
     */
    public function hasColumn($table, $column)
    {
        if (is_string($column)) {

            $column = [$column];
        }

        return $this->hasColumns($table, $column);
    }

    /**
     * Determine if the given table has given columns.
     *
     * @param  string  $table
     * @return bool
     */
    public function hasColumns($table, array $columns)
    {
        $parameters = [];
        $parameters['name'] = 'hasAttribute';
        $parameters['handler'] = 'aql';
        $parameters['columns'] = $columns;

        $command = new Fluent($parameters);
        $compilation = $this->grammar->compileHasColumn($table, $command);

        return $this->connection->statement($compilation['aql']);
    }


    /**
     * Create a database in the schema.
     *
     * @param  string  $name
     * @return bool
     *
     * @throws ArangoException
     */
    public function createDatabase($name)
    {
        return $this->schemaManager->createDatabase($name);
    }

    /**
     * Drop a database from the schema if the database exists.
     *
     * @param  string  $name
     * @return bool
     *
     * @throws ArangoException
     */
    public function dropDatabaseIfExists($name)
    {
        if ($this->schemaManager->hasDatabase($name)) {
            return $this->schemaManager->deleteDatabase($name);
        }

        return true;
    }

    /**
     * Get the database connection instance.
     *
     * @return Connection
     */
    public function getConnection()
    {
        return $this->connection;
    }

    /**
     * @throws QueryException
     */
    protected function handleExceptionsAsQueryExceptions(Closure $callback): mixed
    {
        try {
            return $callback();
        } catch (\Exception $e) {
            throw new QueryException($this->connection->getName(), $e->getMessage(), [], $e);
        }
    }

    /**
     * Silently catch the use of unsupported builder methods.
     */
    public function __call(string $method, mixed $args): void
    {
        Log::warning("The Aranguent Schema Builder doesn't support method '$method'\n");
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace LaravelFreelancerNL\Aranguent\Schema;
6
7		use ArangoClient\Exceptions\ArangoException;
8		use ArangoClient\Schema\SchemaManager;
9		use Closure;
10		use Illuminate\Support\Facades\Log;
11		use Illuminate\Support\Fluent;
12		use LaravelFreelancerNL\Aranguent\Connection;
13		use LaravelFreelancerNL\Aranguent\Exceptions\QueryException;
14		use LaravelFreelancerNL\Aranguent\Schema\Concerns\HandlesAnalyzers;
15		use LaravelFreelancerNL\Aranguent\Schema\Concerns\HandlesViews;
16		use LaravelFreelancerNL\Aranguent\Schema\Concerns\UsesBlueprints;
17
18		class Builder extends \Illuminate\Database\Schema\Builder
19		{
20		use HandlesAnalyzers;
21		use HandlesViews;
		0 ignored issues – show Bug introduced 2023-12-25 12:36 UTC by Report Bug Copy Issue Report The trait `LaravelFreelancerNL\Aran...a\Concerns\HandlesViews` requires the property `$name` which is not provided by `LaravelFreelancerNL\Aranguent\Schema\Builder`. Loading history...
22		use UsesBlueprints;
23
24		/**
25		* The database connection instance.
26		*
27		* @var Connection
28		*/
29		protected $connection;
30
31		protected SchemaManager $schemaManager;
32
33		/**
34		* The schema grammar instance.
35		*
36		* @var Grammar
37		*/
38		protected $grammar;
39
40		/**
41		* Create a new database Schema manager.
42		*
43		* Builder constructor.
44		*/
45	36	public function __construct(Connection $connection)
46		{
47	36	$this->connection = $connection;
48
49	36	$this->grammar = $connection->getSchemaGrammar();
50
51	36	$this->schemaManager = $connection->getArangoClient()->schema();
52		}
53
54		/**
55		* Determine if the given table exists.
56		*
57		* @param string $table
58		* @return bool
59		*/
60	4	public function hasTable($table)
61		{
62	4	return $this->handleExceptionsAsQueryExceptions(function () use ($table) {
63	4	return $this->schemaManager->hasCollection($table);
64	4	});
65		}
66
67		/**
68		* @throws ArangoException
69		*/
70		public function dropIfExists($table): void
71		{
72		$tableExists = $this->hasTable($table);
73		if ($tableExists) {
74		$this->drop($table);
75		}
76		}
77
78		/**
79		* Get all the tables for the database; excluding ArangoDB system collections
80		*
81		* @return array<mixed>
82		*
83		* @throws ArangoException
84		*/
85	2	public function getAllTables(): array
86		{
87	2	return $this->schemaManager->getCollections(true);
88		}
89
90		/**
91		* Rename a table (collection).
92		*
93		* @param string $from
94		* @param string $to
95		*
96		* @throws ArangoException
97		*/
98	1	public function rename($from, $to): bool
99		{
100	1	return (bool) $this->schemaManager->renameCollection($from, $to);
101		}
102
103		/**
104		* Drop a table (collection) from the schema.
105		*
106		* @throws ArangoException
107		*/
108	1	public function drop($table)
109		{
110	1	$this->schemaManager->deleteCollection($table);
111		}
112
113		/**
114		* Drop all tables (collections) from the schema.
115		*
116		* @throws ArangoException
117		*/
118	2	public function dropAllTables(): void
119		{
120	2	$collections = $this->getAllTables();
121
122	2	foreach ($collections as $name) {
123	2	$this->schemaManager->deleteCollection($name->name);
124		}
125		}
126
127		/**
128		* Determine if the given table has a given column.
129		*
130		* @param string $table
131		* @param string $column
132		* @return bool
133		*/
134	1	public function hasColumn($table, $column)
135		{
136	1	if (is_string($column)) {
		0 ignored issues – show introduced 2021-10-26 11:22 UTC by Report Bug Copy Issue Report The condition `is_string($column)` is always `true`. Loading history...
137	1	$column = [$column];
138		}
139
140	1	return $this->hasColumns($table, $column);
141		}
142
143		/**
144		* Determine if the given table has given columns.
145		*
146		* @param string $table
147		* @return bool
148		*/
149	1	public function hasColumns($table, array $columns)
150		{
151	1	$parameters = [];
152	1	$parameters['name'] = 'hasAttribute';
153	1	$parameters['handler'] = 'aql';
154	1	$parameters['columns'] = $columns;
155
156	1	$command = new Fluent($parameters);
157	1	$compilation = $this->grammar->compileHasColumn($table, $command);
158
159	1	return $this->connection->statement($compilation['aql']);
160		}
161
162
163		/**
164		* Create a database in the schema.
165		*
166		* @param string $name
167		* @return bool
168		*
169		* @throws ArangoException
170		*/
171	2	public function createDatabase($name)
172		{
173	2	return $this->schemaManager->createDatabase($name);
174		}
175
176		/**
177		* Drop a database from the schema if the database exists.
178		*
179		* @param string $name
180		* @return bool
181		*
182		* @throws ArangoException
183		*/
184	2	public function dropDatabaseIfExists($name)
185		{
186	2	if ($this->schemaManager->hasDatabase($name)) {
187	1	return $this->schemaManager->deleteDatabase($name);
188		}
189
190	1	return true;
191		}
192
193		/**
194		* Get the database connection instance.
195		*
196		* @return Connection
197		*/
198	1	public function getConnection()
199		{
200	1	return $this->connection;
201		}
202
203		/**
204		* @throws QueryException
205		*/
206	8	protected function handleExceptionsAsQueryExceptions(Closure $callback): mixed
207		{
208		try {
209	8	return $callback();
210	1	} catch (\Exception $e) {
211	1	throw new QueryException($this->connection->getName(), $e->getMessage(), [], $e);
212		}
213		}
214
215		/**
216		* Silently catch the use of unsupported builder methods.
217		*/
218		public function __call(string $method, mixed $args): void
219		{
220		Log::warning("The Aranguent Schema Builder doesn't support method '$method'\n");
221		}
222		}
223

LaravelFreelancerNL / laravel-arangodb

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

Builder::handleExceptionsAsQueryExceptions() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like