Blasttech\EloquentRelatedPlus\HelperMethodTrait

Complexity

Total Complexity

16

Size/Duplication

Total Lines	128
Duplicated Lines	0 %

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	parseRelationNames()	0	16	3
A	getTableWithAlias()	0	7	3
A	columnWithTableName()	0	3	2
A	removeGlobalScope()	0	8	2
A	toSqlWithBindings()	0	17	3
A	getTableFromColumn()	0	5	2
A	getRelationTables()	0	9	1

<?php

namespace Blasttech\EloquentRelatedPlus;

use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Relations\Relation;

/**
 * Trait HelperMethodTrait
 *
 * @property array order_fields
 * @property array order_defaults
 * @property array order_relations
 * @property array order_with
 * @property array search_fields
 * @property string connection
 */
trait HelperMethodTrait
{
    /**
     * Get relation table name and alias
     *
     * @param Relation $relation
     * @return \stdClass
     */
    protected function getRelationTables($relation)
    {
        $table = new \stdClass();
        $table->name = $relation->getRelated()->getTable();
        // if using a 'table' AS 'tableAlias' in a from statement, otherwise alias will be the table name
        $from = explode(' ', $relation->getQuery()->getQuery()->from);
        $table->alias = array_pop($from);

        return $table;
    }

    /**
     * Get the relations from a relation name
     * $relationName can be a single relation
     * Usage for User model:
     * parseRelationNames('customer') returns [$user->customer()]
     * parseRelationNames('customer.contact') returns [$user->customer(), $user->customer->contact()]
     *
     * @param string $relationName
     * @return Relation[]
     */
    protected function parseRelationNames($relationName)
    {
        $relationNames = explode('.', $relationName);
        $parentRelationName = null;
        $relations = [];

        foreach ($relationNames as $relationName) {

$relationName is overwriting one of the parameters of this function.

            if (is_null($parentRelationName)) {
                $relations[] = $this->$relationName();
                $parentRelationName = $this->$relationName()->getRelated();
            } else {
                $relations[] = $parentRelationName->$relationName();
            }
        }

        return $relations;
    }

    /**
     * Return the sql for a query with the bindings replaced with the binding values
     *
     * @param Builder $builder
     * @return string
     */
    protected function toSqlWithBindings($builder)
    {
        $replacements = array_map('addslashes', $builder->getBindings());

It seems like $builder->getBindings() can also be of type Illuminate\Database\Eloquent\Builder; however, parameter $arr1 of array_map() does only seem to accept array, maybe add an additional type check?

        $sql = $builder->toSql();

        foreach ($replacements as &$replacement) {
            if (!is_numeric($replacement)) {
                $replacement = '"' . $replacement . '"';
            }
        }

        return preg_replace_callback(
            '/(\?)(?=(?:[^\'"]|["\'][^\'"]*["\'])*$)/',
            function () use (&$replacements) {
                return array_shift($replacements);
            },
            $sql
        );
    }

    /**
     * Add table name to column name if table name not already included in column name
     *
     * @param string $table
     * @param string $column
     * @return string
     */
    protected function columnWithTableName($table, $column)
    {
        return (preg_match('/(' . $table . '\.|`' . $table . '`)/i', $column) > 0 ? '' : $table . '.') . $column;
    }

    /**
     * Get table name from column name
     *
     * @param string $column
     * @return string
     */
    protected function getTableFromColumn($column)
    {
        $periodPos = strpos($column, '.');

        return ($periodPos !== false ? substr($column, 0, $periodPos) : $column);

The condition $periodPos !== false can never be false.

    }

    /**
     * Get table name with alias if different to table name
     *
     * @param \stdClass $table
     * @return string
     */
    protected function getTableWithAlias($table)
    {
        if ($table->alias !== '' && $table->name !== $table->alias) {
            return $table->name . ' AS ' . $table->alias;
        }

        return $table->name;
    }

    /**
     * Remove a global scope if it exists
     *
     * @param Builder $query
     * @param string $scopeName
     * @return Builder
     */
    protected function removeGlobalScope($query, $scopeName)
    {
        $globalScopes = $this->getGlobalScopes();

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

        if (isset($globalScopes[$scopeName])) {
            $query->withoutGlobalScope($scopeName);
        }

        return $query;
    }
}