Neurony\Url\Traits\HasSlug

Complexity

Total Complexity

31

Size/Duplication

Total Lines	221
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

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	14	3
A	generateNonUniqueSlug()	0	14	4
A	makeSlugUnique()	0	11	3
A	slugHasBeenSupplied()	0	14	4
A	slugHasChanged()	0	6	2
A	getSlugSource()	0	10	3
A	slugAlreadyExists()	0	6	2
A	initSlugOptions()	0	8	2
A	validateSlugOptions()	0	10	3

<?php

namespace Neurony\Url\Traits;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Str;
use Neurony\Url\Exceptions\SlugException;
use Neurony\Url\Options\SlugOptions;

trait HasSlug
{
    /**
     * The container for all the options necessary for this trait.
     * Options can be viewed in the Neurony\Url\Options\SlugOptions file.
     *
     * @var SlugOptions
     */
    protected $slugOptions;

    /**
     * Set the options for the HasSlug trait.
     *
     * @return SlugOptions
     */
    abstract public function getSlugOptions(): SlugOptions;

    /**
     * Boot the trait.
     *
     * @return void
     */
    public static function bootHasSlug(): void
    {
        static::creating(function (Model $model) {
            $model->generateSlugOnCreate();
        });

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

    /**
     * Handle setting the slug on model creation.
     *
     * @return void
     * @throws SlugException
     */
    protected function generateSlugOnCreate(): void
    {
        $this->initSlugOptions();

        if ($this->slugOptions->generateSlugOnCreate === false) {
            return;
        }

        $this->generateSlug();
    }

    /**
     * Handle setting the slug on model update.
     *
     * @return void
     * @throws SlugException
     */
    protected function generateSlugOnUpdate(): void
    {
        $this->initSlugOptions();

        if ($this->slugOptions->generateSlugOnUpdate === false) {
            return;
        }

        $this->generateSlug();
    }

    /**
     * The logic for actually setting the slug.
     *
     * @return void
     * @throws SlugException
     */
    public function generateSlug(): void
    {
        $this->initSlugOptions();

        if ($this->slugHasBeenSupplied()) {
            $slug = $this->generateNonUniqueSlug();

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

            $this->setAttribute($this->slugOptions->toField, $slug);

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

        }
    }

    /**
     * Generate a non unique slug for this record.
     *
     * @return string
     */
    protected function generateNonUniqueSlug(): string
    {
        if ($this->slugHasChanged()) {
            $source = $this->getAttribute($this->slugOptions->toField);

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

            return Str::is('/', $source) ? $source : Str::slug($source);
        }

        $source = $this->getSlugSource();

        return Str::is('/', $source) ? $source : Str::slug(
            $source, $this->slugOptions->slugSeparator, $this->slugOptions->slugLanguage
        );
    }

    /**
     * Make the given slug unique.
     *
     * @param string $slug
     * @return string
     */
    protected function makeSlugUnique(string $slug): string
    {
        $original = $slug;
        $i = 1;

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

        return $slug;
    }

    /**
     * Check if the $fromField slug has been supplied.
     * If not, then skip the entire slug generation.
     *
     * @return bool
     */
    protected function slugHasBeenSupplied(): bool
    {
        if (is_array($this->slugOptions->fromField)) {
            foreach ($this->slugOptions->fromField as $field) {
                if ($this->getAttribute($field) !== null) {

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

                    return true;
                }
            }

            return false;
        }

        return $this->getAttribute($this->slugOptions->fromField) !== null;

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

    }

    /**
     * Determine if a custom slug has been saved.
     *
     * @return bool
     */
    protected function slugHasChanged(): bool
    {
        return
            $this->getOriginal($this->slugOptions->toField) &&

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

            $this->getOriginal($this->slugOptions->toField) != $this->getAttribute($this->slugOptions->toField);

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

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

    }

    /**
     * Get the string that should be used as base for the slug.
     *
     * @return string
     */
    protected function getSlugSource(): string
    {
        if (is_callable($this->slugOptions->fromField)) {
            return call_user_func($this->slugOptions->fromField, $this);
        }

        return collect($this->slugOptions->fromField)->map(function ($field) {
            return $this->getAttribute($field) ?: '';

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

        })->implode($this->slugOptions->slugSeparator);
    }

    /**
     * Check if the given slug already exists on another record.
     *
     * @param string $slug
     * @return bool
     */
    protected function slugAlreadyExists(string $slug): bool
    {
        return (bool) static::withoutGlobalScopes()->where($this->slugOptions->toField, $slug)
            ->where($this->getKeyName(), '!=', $this->getKey() ?: '0')

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

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

            ->first();
    }

    /**
     * Both instantiate the slug options as well as validate their contents.
     *
     * @return void
     * @throws SlugException
     */
    protected function initSlugOptions(): void
    {
        if ($this->slugOptions === null) {
            $this->slugOptions = $this->getSlugOptions();
        }

        $this->validateSlugOptions();
    }

    /**
     * Check if mandatory slug options have been properly set from the model.
     * Check if $fromField and $toField have been set.
     *
     * @return void
     * @throws SlugException
     */
    protected function validateSlugOptions(): void
    {
        if (! $this->slugOptions->fromField) {
            throw SlugException::mandatoryFromField(static::class);
        }

        if (! $this->slugOptions->toField) {
            throw SlugException::mandatoryToField(static::class);
        }
    }
}