LaravelFreelancerNL\Aranguent\Query\Concerns\HasAliases::normalizeColumn()

Complexity

Conditions	9
Paths	5

Size

Total Lines	30
Code Lines	13

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	14
CRAP Score	9

Importance

Changes	2
Bugs	0	Features	0

2 Methods

Rating	Name	Duplication	Size	Complexity
A	HasAliases::convertColumnId()	0	7	3
A	HasAliases::getColumnAlias()	0	7	2

<?php

declare(strict_types=1);

namespace LaravelFreelancerNL\Aranguent\Query\Concerns;

use Exception;
use Illuminate\Support\Str;

trait HasAliases
{
    protected $tableAliases = [];

    protected $columnAliases = [];

    /**
     * @param  string  $table
     * @param  string|null  $alias
     * @return string
     */
    public function registerTableAlias(string $table, string $alias = null): string
    {
        if ($alias == null && stripos($table, ' as ') !== false) {

It seems like you are loosely comparing $alias of type null|string against null; this is ambiguous if the string can be empty. Consider using a strict comparison === instead.

            [$table, $alias] = explode(' as ', $table);
        }
        if ($alias == null) {

It seems like you are loosely comparing $alias of type null|string against null; this is ambiguous if the string can be empty. Consider using a strict comparison === instead.

            $alias = $this->generateTableAlias($table);
        }
        $this->tableAliases[$table] = $alias;

        return $alias;
    }

    protected function isTableAlias(string $alias)
    {
        return in_array($alias, $this->tableAliases);
    }

    protected function getTableAlias(string $table): string|null
    {
        if (isset($this->tableAliases[$table])) {
            return $this->tableAliases[$table];
        }

        return null;
    }

    /**
     * Extract table and alias from sql alias notation (entity AS `alias`)
     *
     * @param string $entity
     * @param int|string|null $key
     * @return array<mixed>
     * @throws Exception
     */
    protected function extractAlias(string $entity, int|string $key = null): array
    {
        $results = preg_split("/\sas\s/i", $entity);

        if ($results === false) {
            throw new Exception('Column splitting failed');
        }

        if (isset($results[1])) {
            $results[1] = trim($results[1], '`');
        }
        if (! isset($results[1]) && is_string($key)) {
            $results[1] = $key;
        }
        if (! isset($results[1])) {
            $results[1] = $results[0];
        }

        return $results;
    }

    protected function generateTableAlias(string $table, string $postfix = 'Doc'): string
    {
        return Str::camel(Str::singular($table)) . $postfix;
    }

    protected function replaceTableForAlias($reference): string
    {
        $referenceParts = explode('.', $reference);
        $first = array_shift($referenceParts);
        $alias = $this->getTableAlias($first);
        if ($alias == null) {

It seems like you are loosely comparing $alias of type null|string against null; this is ambiguous if the string can be empty. Consider using a strict comparison === instead.

            $alias = $first;
        }
        array_unshift($referenceParts, $alias);

        return implode('.', $referenceParts);
    }

    protected function prefixAlias(string $target, string $value): string
    {
        $alias = $this->getTableAlias($target);

        if (Str::startsWith($value, $alias . '.')) {
            return $value;
        }

        return $alias . '.' . $value;
    }

    /**
     * @param string $column
     * @param string|null $alias
     * @return bool
     * @throws Exception
     */
    public function registerColumnAlias(string $column, string $alias = null): bool
    {
        if (preg_match("/\sas\s/i", $column)) {
            [$column, $alias] = $this->extractAlias($column);
        }

        if (isset($alias)) {
            $this->columnAliases[$column] = $alias;
            return true;
        }

        return false;
    }

    protected function getColumnAlias(string $column): string|null
    {
        if (isset($this->columnAliases[$column])) {
            return $this->columnAliases[$column];
        }

        return null;
    }

    /**
     * @param array<mixed>|string $column
     * @return array<mixed>|string
     */
    protected function convertColumnId(array|string $column): array|string
    {
        if (is_string($column) || is_array($column)) {

The condition is_array($column) is always true.

            $column = $this->convertIdToKey($column);

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

        }

        return $column;
    }
}