Staudenmeir\LaravelAdjacencyList\Eloquent\Traits\BuildsAdjacencyListQueries

Complexity

Total Complexity

17

Size/Duplication

Total Lines	116
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	0	Features	0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	getModels()	0	29	4
A	replacePathSeparator()	0	7	2
A	withGlobalScopes()	0	7	2
B	getExpressionGrammar()	0	38	9

<?php

namespace Staudenmeir\LaravelAdjacencyList\Eloquent\Traits;

use Illuminate\Database\PostgresConnection;
use RuntimeException;
use Staudenmeir\LaravelAdjacencyList\Query\Grammars\FirebirdGrammar;
use Staudenmeir\LaravelAdjacencyList\Query\Grammars\MariaDbGrammar;
use Staudenmeir\LaravelAdjacencyList\Query\Grammars\MySqlGrammar;
use Staudenmeir\LaravelAdjacencyList\Query\Grammars\PostgresGrammar;
use Staudenmeir\LaravelAdjacencyList\Query\Grammars\SingleStoreGrammar;
use Staudenmeir\LaravelAdjacencyList\Query\Grammars\SQLiteGrammar;
use Staudenmeir\LaravelAdjacencyList\Query\Grammars\SqlServerGrammar;

trait BuildsAdjacencyListQueries
{
    /**
     * Get the hydrated models without eager loading.
     *
     * @param array $columns
     * @return \Illuminate\Database\Eloquent\Model[]
     */
    public function getModels($columns = ['*'])
    {
        $items = $this->query->get($columns)->all();

        if ($this->getConnection() instanceof PostgresConnection) {

It seems like getConnection() must be provided by classes using this trait. How about adding it as abstract method to this trait?

            $path = $this->model->getPathName();

            if (isset($items[0]->$path)) {
                $this->replacePathSeparator(
                    $items,
                    $path,
                    $this->model->getPathSeparator()
                );

                foreach ($this->model->getCustomPaths() as $path) {
                    $this->replacePathSeparator(
                        $items,
                        $path['name'],
                        $path['separator']
                    );
                }
            }
        }

        $table = (new $this->model())->getTable();

        $models = $this->model->hydrate($items)->each->setTable($table);

        return $models->all();
    }

    /**
     * Replace the separator in a PostgreSQL path column.
     *
     * @param array $items
     * @param string $path
     * @param string $separator
     * @return void
     */
    protected function replacePathSeparator(array $items, $path, $separator)
    {
        foreach ($items as $item) {
            $item->$path = str_replace(
                ',',
                $separator,
                substr($item->$path, 1, -1)
            );
        }
    }

    /**
     * Get the expression grammar.
     *
     * @return \Staudenmeir\LaravelAdjacencyList\Query\Grammars\ExpressionGrammar
     */
    public function getExpressionGrammar()
    {
        $driver = $this->query->getConnection()->getDriverName();

        switch ($driver) {
            case 'mysql':
                $grammar = $this->query->getConnection()->isMaria()
                    ? new MariaDbGrammar($this->model)
                    : new MySqlGrammar($this->model);

                return $this->query->getConnection()->withTablePrefix($grammar);
            case 'mariadb':
                return $this->query->getConnection()->withTablePrefix(
                    new MariaDbGrammar($this->model)
                );
            case 'pgsql':
                return $this->query->getConnection()->withTablePrefix(
                    new PostgresGrammar($this->model)
                );
            case 'sqlite':
                return $this->query->getConnection()->withTablePrefix(
                    new SQLiteGrammar($this->model)
                );
            case 'sqlsrv':
                return $this->query->getConnection()->withTablePrefix(
                    new SqlServerGrammar($this->model)
                );
            case 'singlestore':
                return $this->query->getConnection()->withTablePrefix(
                    new SingleStoreGrammar($this->model)
                );
            case 'firebird':
                return $this->query->getConnection()->withTablePrefix(
                    new FirebirdGrammar($this->model)
                );
        }

        throw new RuntimeException('This database is not supported.'); // @codeCoverageIgnore
    }

    /**
     * Register all passed global scopes.
     *
     * @param array $scopes
     * @return $this
     */
    public function withGlobalScopes(array $scopes)
    {
        foreach ($scopes as $identifier => $scope) {
            $this->withGlobalScope($identifier, $scope);

The method withGlobalScope() does not exist on Staudenmeir\LaravelAdjacencyList\Eloquent\Traits\BuildsAdjacencyListQueries. Did you maybe mean withGlobalScopes()?

        }

        return $this;
    }
}