Spatie\Sluggable\HasSlug

Complexity

Total Complexity

31

Size/Duplication

Total Lines	166
Duplicated Lines	3.61 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes

0

13 Methods

Rating	Name	Duplication	Size	Complexity
	getSlugOptions()	0	1	?
A	bootHasSlug()	0	10	1
A	generateSlugOnCreate()	0	10	2
A	generateSlugOnUpdate()	0	10	2
A	generateSlug()	0	6	1
A	addSlug()	0	14	2
B	generateNonUniqueSlug()	6	24	7
A	hasCustomSlugBeenUsed()	0	6	1
A	getSlugSourceString()	0	16	2
A	makeSlugUnique()	0	11	3
A	otherRecordExistsWithSlug()	0	18	3
A	usesSoftDeletes()	0	8	2
A	ensureValidSlugOptions()	0	14	5

<?php

namespace Spatie\Sluggable;

use Illuminate\Support\Str;
use Illuminate\Database\Eloquent\Model;

trait HasSlug
{
    /** @var \Spatie\Sluggable\SlugOptions */
    protected $slugOptions;

    abstract public function getSlugOptions(): SlugOptions;

    protected static function bootHasSlug()
    {
        static::creating(function (Model $model) {
            $model->generateSlugOnCreate();
        });

        static::updating(function (Model $model) {
            $model->generateSlugOnUpdate();
        });
    }

    protected function generateSlugOnCreate()
    {
        $this->slugOptions = $this->getSlugOptions();

        if (! $this->slugOptions->generateSlugsOnCreate) {
            return;
        }

        $this->addSlug();
    }

    protected function generateSlugOnUpdate()
    {
        $this->slugOptions = $this->getSlugOptions();

        if (! $this->slugOptions->generateSlugsOnUpdate) {
            return;
        }

        $this->addSlug();
    }

    public function generateSlug()
    {
        $this->slugOptions = $this->getSlugOptions();

        $this->addSlug();
    }

    protected function addSlug()
    {
        $this->ensureValidSlugOptions();

        $slug = $this->generateNonUniqueSlug();

        if ($this->slugOptions->generateUniqueSlugs) {
            $slug = $this->makeSlugUnique($slug);
        }

        $slugField = $this->slugOptions->slugField;

        $this->$slugField = $slug;
    }

    protected function generateNonUniqueSlug(): string
    {
        $slugField = $this->slugOptions->slugField;

        if ($this->hasCustomSlugBeenUsed() && ! empty($this->$slugField)) {
            return $this->$slugField;
        }

        $slugSourceString = $this->getSlugSourceString();

        if (!empty($this->slugOptions->prefixSlug) || !empty($this->slugOptions->suffixSlug)) {

            if (!empty($this->slugOptions->prefixSlug)) {

This code seems to be duplicated across your project.

                $slugSourceString  = $this->slugOptions->prefixSlug . $this->slugOptions->slugSeparator . $slugSourceString;
            }

            if (!empty($this->slugOptions->suffixSlug)) {

This code seems to be duplicated across your project.

                $slugSourceString  = $slugSourceString . $this->slugOptions->slugSeparator . $this->slugOptions->suffixSlug;
            }

        }

        return Str::slug($slugSourceString, $this->slugOptions->slugSeparator, $this->slugOptions->slugLanguage);
    }

    protected function hasCustomSlugBeenUsed(): bool
    {
        $slugField = $this->slugOptions->slugField;

        return $this->getOriginal($slugField) != $this->$slugField;

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

    }

    protected function getSlugSourceString(): string
    {
        if (is_callable($this->slugOptions->generateSlugFrom)) {
            $slugSourceString = call_user_func($this->slugOptions->generateSlugFrom, $this);

            return substr($slugSourceString, 0, $this->slugOptions->maximumLength);
        }

        $slugSourceString = collect($this->slugOptions->generateSlugFrom)
            ->map(function (string $fieldName) : string {
                return data_get($this, $fieldName, '');
            })
            ->implode($this->slugOptions->slugSeparator);

        return substr($slugSourceString, 0, $this->slugOptions->maximumLength);
    }

    protected function makeSlugUnique(string $slug): string
    {
        $originalSlug = $slug;
        $i = 1;

        while ($this->otherRecordExistsWithSlug($slug) || $slug === '') {
            $slug = $originalSlug.$this->slugOptions->slugSeparator.$i++;
        }

        return $slug;
    }

    protected function otherRecordExistsWithSlug(string $slug): bool
    {
        $key = $this->getKey();

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

        if ($this->incrementing) {

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

            $key = $key ?? '0';
        }

        $query = static::where($this->slugOptions->slugField, $slug)
            ->where($this->getKeyName(), '!=', $key)

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

            ->withoutGlobalScopes();

        if ($this->usesSoftDeletes()) {
            $query->withTrashed();
        }

        return $query->exists();
    }

    protected function usesSoftDeletes()
    {
        if (in_array('Illuminate\Database\Eloquent\SoftDeletes', class_uses($this))) {
            return true;
        }

        return false;
    }

    protected function ensureValidSlugOptions()
    {
        if (is_array($this->slugOptions->generateSlugFrom) && ! count($this->slugOptions->generateSlugFrom)) {
            throw InvalidOption::missingFromField();
        }

        if (! strlen($this->slugOptions->slugField)) {
            throw InvalidOption::missingSlugField();
        }

        if ($this->slugOptions->maximumLength <= 0) {
            throw InvalidOption::invalidMaximumLength();
        }
    }
}