Spatie\BinaryUuid\HasBinaryUuid

Complexity

Total Complexity

59

Size/Duplication

Total Lines	264
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes

0

26 Methods

Rating	Name	Duplication	Size	Complexity
A	getIncrementing()	0	4	1
A	scopeWithUuid()	0	16	3
A	scopeWithUuidRelation()	0	12	2
A	generateUuid()	0	4	1
A	encodeUuid()	0	12	3
A	decodeUuid()	0	8	2
A	isBinary()	0	4	1
A	getUuidKeys()	0	4	3
B	toArray()	0	37	9
A	getRelatedBinaryKeyName()	0	6	2
A	getAttribute()	0	10	3
A	setAttribute()	0	8	2
A	getUuidSuffix()	0	4	2
A	uuidTextAttribute()	0	12	3
A	getUuidAttributes()	0	11	1
A	getUuidTextAttribute()	0	10	3
A	setUuidTextAttribute()	0	10	2
A	getQueueableId()	0	4	1
A	newQueryForRestoration()	0	4	1
A	newEloquentBuilder()	0	4	1
A	bootHasBinaryUuid()	0	14	3
A	getRouteKeyName()	0	8	2
A	getKeyName()	0	4	3
A	resolveRouteBinding()	0	12	2
A	strUuidSuffix()	0	6	1
A	decodeIdArray()	0	8	2

<?php

namespace Spatie\BinaryUuid;

use Exception;
use Ramsey\Uuid\Uuid;
use Illuminate\Database\Eloquent\Model;

trait HasBinaryUuid
{
    protected static function bootHasBinaryUuid()
    {
        static::creating(function (Model $model) {
            $uuidAttributes = $model->getUuidAttributes();

            foreach ($uuidAttributes as $key) {
                if ($model->{$key}) {
                    continue;
                }

                $model->{$key} = static::encodeUuid(static::generateUuid());
            }
        });
    }

    public static function scopeWithUuid(Builder $builder, $uuid, $field = null): Builder
    {
        if ($field) {
            return static::scopeWithUuidRelation($builder, $uuid, $field);
        }

        if ($uuid instanceof Uuid) {
            $uuid = (string) $uuid;
        }

        $uuid = (array) $uuid;

        return $builder->whereKey(array_map(function (string $modelUuid) {
            return static::encodeUuid($modelUuid);
        }, $uuid));
    }

    public static function scopeWithUuidRelation(Builder $builder, $uuid, string $field): Builder
    {
        if ($uuid instanceof Uuid) {
            $uuid = (string) $uuid;
        }

        $uuid = (array) $uuid;

        return $builder->whereIn($field, array_map(function (string $modelUuid) {

The method whereIn does not exist on object<Spatie\BinaryUuid\Builder>? Since you implemented __call, maybe consider adding a @method annotation.

            return static::encodeUuid($modelUuid);
        }, $uuid));
    }

    public static function generateUuid() : string
    {
        return Uuid::uuid1();
    }

    public static function encodeUuid($uuid): string
    {
        if (! Uuid::isValid($uuid)) {
            return $uuid;
        }

        if (! $uuid instanceof Uuid) {
            $uuid = Uuid::fromString($uuid);
        }

        return $uuid->getBytes();
    }

    public static function decodeUuid(string $binaryUuid): string
    {
        if (Uuid::isValid($binaryUuid)) {
            return $binaryUuid;
        }

        return Uuid::fromBytes($binaryUuid)->toString();
    }

    public function isBinary($uuidStr)
    {
        return preg_match('~[^\x20-\x7E\t\r\n]~', $uuidStr) > 0;
    }

    public function getUuidKeys()
    {
        return (property_exists($this, 'uuids') && is_array($this->uuids)) ? $this->uuids : [];

The property uuids does not exist. Did you maybe forget to declare it?

    }

    public function toArray()
    {
        $uuidAttributes = $this->getUuidAttributes();

        $array = parent::toArray();
        $pivotUuids = [];

$pivotUuids is not used, you could remove the assignment.

        if (! $this->exists || ! is_array($uuidAttributes)) {

The property exists does not exist. Did you maybe forget to declare it?

            return $array;
        }

        foreach ($uuidAttributes as $attributeKey) {
            if (! array_key_exists($attributeKey, $array)) {
                continue;
            }
            $uuidKey = $this->getRelatedBinaryKeyName($attributeKey);
            $array[$attributeKey] = $this->{$uuidKey};
        }

        if (isset($array['pivot'])) {
            $pivotUuids = $array['pivot'];

            if (! is_array($pivotUuids)) {
                $pivotUuids = get_object_vars($pivotUuids);
            }

            foreach ($pivotUuids as $key => $uuid) {
                if ($this->isBinary($uuid)) {
                    $pivotUuids[$key] = $this->decodeUuid($uuid);
                }
            }

            $array['pivot'] = $pivotUuids;
        }

        return $array;
    }

    public function getRelatedBinaryKeyName($attribute): string
    {
        $suffix = $this->getUuidSuffix();

        return preg_match('/(?:[a-zA-Z_]+)?id/i', $attribute) ? "{$attribute}{$suffix}" : $attribute;
    }

    public function getAttribute($key)
    {
        $uuidKey = $this->uuidTextAttribute($key);

        if ($uuidKey && $this->{$uuidKey} !== null) {

The expression $uuidKey of type string|false is loosely compared to true; this is ambiguous if the string can be empty. You might want to explicitly use !== false instead.

            return static::decodeUuid($this->{$uuidKey});
        }

        return parent::getAttribute($key);
    }

    public function setAttribute($key, $value)
    {
        if ($this->uuidTextAttribute($key)) {

The expression $this->uuidTextAttribute($key) of type string|false is loosely compared to true; this is ambiguous if the string can be empty. You might want to explicitly use !== false instead.

            $value = static::encodeUuid($value);
        }

        return parent::setAttribute($key, $value);
    }

    protected function getUuidSuffix()
    {
        return (property_exists($this, 'uuidSuffix')) ? $this->uuidSuffix : '_text';

The property uuidSuffix does not exist. Did you maybe forget to declare it?

    }

    protected function uuidTextAttribute($key)
    {
        $uuidAttributes = $this->getUuidAttributes();
        $suffix = $this->getUuidSuffix();
        $offset = -(strlen($suffix));

        if (substr($key, $offset) == $suffix && in_array(($uuidKey = substr($key, 0, $offset)), $uuidAttributes)) {
            return $uuidKey;
        }

        return false;
    }

    public function getUuidAttributes()
    {
        $uuidKeys = $this->getUuidKeys();

        // non composite primary keys will return a string so casting required
        $key = (array) $this->getKeyName();

        $uuidAttributes = array_unique(array_merge($uuidKeys, $key));

        return $uuidAttributes;
    }

    public function getUuidTextAttribute(): ?string
    {
        $key = $this->getKeyName();

        if (! $this->exists || is_array($key)) {
            return null;
        }

        return static::decodeUuid($this->{$key});
    }

    public function setUuidTextAttribute(string $uuid)
    {
        $key = $this->getKeyName();

        if (! is_string($key)) {
            throw new Exception('composite keys not allowed for attribute mutation');
        }

        $this->{$key} = static::encodeUuid($uuid);
    }

    public function getQueueableId()
    {
        return base64_encode($this->{$this->getKeyName()});
    }

    public function newQueryForRestoration($id)
    {
        return $this->newQueryWithoutScopes()->whereKey(base64_decode($id));

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

    }

    public function newEloquentBuilder($query)
    {
        return new Builder($query);
    }

    public function getRouteKeyName()
    {
        $key = $this->primaryKey;

The property primaryKey does not exist. Did you maybe forget to declare it?

        $keyName = is_string($key) ? $this->strUuidSuffix($key) : array_map([&$this, 'strUuidSuffix'], $key);

        return $keyName;
    }

    public function getKeyName()
    {
        return (! property_exists($this, 'primaryKey') || $this->primaryKey === 'id') ? 'uuid' : $this->primaryKey;
    }

    public function getIncrementing()
    {
        return false;
    }

    public function resolveRouteBinding($value)
    {
        $keyName = $this->getRouteKeyName();

        if (is_array($keyName)) {
            $parsed = explode(':', strval($value), count($keyName));

            $value = array_combine($keyName, $parsed);
        }

        return $this->withUuid($value)->first();

The method withUuid() does not exist on Spatie\BinaryUuid\HasBinaryUuid. Did you maybe mean scopeWithUuid()?

    }

    public function strUuidSuffix($str)
    {
        $suffix = $this->getUuidSuffix();

        return "{$str}{$suffix}";
    }

    private function decodeIdArray($ids)

This method is not used, and could be removed.

    {
        foreach ($ids as $key => $id) {
            $ids[$key] = base64_decode($id);
        }

        return $ids;
    }
}