HasSlugMaker::bootHasSlugMaker() - Code Metrics - Inspection of "Fix bug trait method name" - fomvasss/laravel-slugmaker - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( 174d79...4b253c )

by Vasyl
created 2017-12-22 08:47 UTC
HasSlugMaker::bootHasSlugMaker() A

↳ Parent: HasSlugMaker
Complexity

Conditions	1
Paths	1
Size

Total Lines	12
Code Lines	6
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	1
eloc	6
nc	1
nop	0
dl	0
loc	12
rs	9.4285
c	0
b	0
f	0
<?php

namespace Fomvasss\SlugMaker;

use Illuminate\Database\Eloquent\Model;
filter:
    dependency_paths: ["lib/*"]

trait HasSlugMaker
{
    protected $slugOptions;

    /**
     * Get the options for generating the slug.
     */
    abstract public function getSlugMakerOptions(): SlugMakerOptions;

    /**
     * The morph relations (has one) for the model.
     *
     * @return mixed
     */
    public function slug()
    {
        return $this->morphOne(\Fomvasss\SlugMaker\Models\Slug::class, 'slugable');
        return $this->/** @scrutinizer ignore-call */ morphOne(\Fomvasss\SlugMaker\Models\Slug::class, 'slugable');
    }

    /**
     * The boot trait events in class (model).
     */
    protected static function bootHasSlugMaker()
    {
        static::created(function (Model $model) {
            $model->generateSlugOnCreate();
        });

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

        static::deleted(function (Model $model) {
            $model->removeSlugsOnDeleted();
        });
    }

    /**
     * Handle adding slug on model creation.
     */
    protected function generateSlugOnCreate()

    {
        $this->slugOptions = $this->getSlugMakerOptions();

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

        $slug = $this->getSlug();
        $this->storeSlug($slug);
    }

    /**
     * Handle adding slug on model update.
     */
    protected function generateSlugOnUpdate()

    {
        $this->slugOptions = $this->getSlugMakerOptions();

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

        $slug = $this->getSlug();
        $this->storeSlug($slug);
    }

    /**
     * The store (create or update) slug in database.
     *
     * @param $slug
     */
    protected function storeSlug($slug)
    {
        if ($this->slug) {

            //$this->slug()->updateOrCreate(['name' => $this->slug->name], [$this->slugField => $slug]);
            $this->slug()->update(['name' => $slug]);
        } else {
            $this->slug()->create(['name' => $slug]);
        }
    }

    /**
     * Remove the slug in database. Default migration not using softdelete.
     */
    protected function removeSlugsOnDeleted()
    {
        $this->slugOptions = $this->getSlugMakerOptions();

        if ($this->slug && $this->slugOptions->removeSlugsOnDelete) {

            $this->slug()->delete();
        }
    }

    /**
     * Get the slug with the model.
     */
    protected function getSlug()
    {
        $this->guardAgainstInvalidSlugOptions();

        $slug = $this->generateNonUniqueSlug();

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

        return $slug;
    }

    /**
     * Generate a non unique slug for this record.
     */
    protected function generateNonUniqueSlug(): string
    {
        $this->slugOptions = $this->getSlugMakerOptions();

        return str_slug($this->getSlugSourceString(), $this->slugOptions->slugSeparator);
    }

    /**
     * Get the string that should be used as base for the slug.
     */
    protected function getSlugSourceString(): string
    {
        if (is_callable($this->slugOptions->generateSlugFrom)) {
            $slugSourceString = call_user_func($this->slugOptions->generateSlugFrom, $this);

            return $this->getClippedSlugWithPrefixSuffix($slugSourceString);
        }

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

        return $this->getClippedSlugWithPrefixSuffix($slugSourceString);
    }

    /**
     * Add prefix and suffix to slug. Clipped string.
     */
    public function getClippedSlugWithPrefixSuffix(string $slugSourceString): string
    {
        $prefix = $this->slugOptions->slugPrefix;
        $suffix = $this->slugOptions->slugSuffix;
        $lengthPrefix = strlen($prefix);
        $lengthSuffix = strlen($suffix);

        if ($lengthPrefix + $lengthSuffix) {
            $limitWithoutPrefixSuffix = $this->slugOptions->maximumLength - (++$lengthPrefix + ++$lengthSuffix);

            if ($limitWithoutPrefixSuffix < 1) {
                return str_limit($prefix.' '.$suffix, $this->slugOptions->maximumLength);
            }

            return $prefix.' '.str_limit($slugSourceString, $limitWithoutPrefixSuffix, '').' '.$suffix;
        }

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

    /**
     * Make the given slug unique.
     */
    protected function makeSlugUnique(string $slug): string
    {
        $originalSlug = $slug;
        $i = 1;
        while ($this->otherRecordExistsWithSlug($slug) || $slug === '') {
            $slug = $originalSlug.'-'.$i++;
        }

        return $slug;
    }

    /**
     * Determine if a record exists with the given slug.
     */
    protected function otherRecordExistsWithSlug(string $slug): bool
    {
        return (bool) \Fomvasss\SlugMaker\Models\Slug::where('name', $slug)
            ->withoutGlobalScopes()
            ->first();
    }

    /**
     * This function will throw an exception when any of the options is missing or invalid.
     */
    protected function guardAgainstInvalidSlugOptions()
    {
        if (! count($this->slugOptions->generateSlugFrom)) {
            throw InvalidOption::missingFromField();
        }

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

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

    /**
     * The scope for fet slug name.
     */
    public function scopeGetSlugName()
    {
        if ($this->slug) {

            return $this->slug->name;
        }
        return null;
    }

    /**
     * Models by slugs.
     *
     * @param $query
     * @param string $slug
     * @return mixed
     */
    public function scopeBySlugs($query, $slug)
    {
        $slugs = is_array($slug) ? $slug : [$slug];

        return $query->whereHas('slug', function ($q) use ($slugs) {
            $q->whereIn('name', $slugs);
        });
    }

    /**
     * Find first model by slug.
     *
     * @param $query
     * @param string $slug
     * @return mixed
     */
    public function scopeFindBySlug($query, string $slug)
    {
        return $this->scopeBySlugs($query, $slug)->first();
    }

    /**
     * Find first model by slug or throw exciption.
     *
     * @param $query
     * @param string $slug
     * @return mixed
     */
    public function scopeFindOrFailBySlug($query, string $slug)
    {
        return $this->scopeBySlugs($query, $slug)->firstOrFail();
    }

    /**
     * Get models by slugs.
     *
     * @param $query
     * @param $slugs
     * @return mixed
     */
    public function scopeGetBySlugs($query, $slugs)
    {
        return $this->scopeBySlugs($query, $slugs)->get();
    }

    /**
     * Get array ids by slugs.
     *
     * @param $query
     * @param array $slugs
     * @return array
     */
    public function scopeGetArrayIdsBySlugs($query, array $slugs): array
    {
        return $this->scopeBySlugs($query, $slugs)->pluck('id')->toArray();
        return $this->scopeBySlugs($query, /** @scrutinizer ignore-type */ $slugs)->pluck('id')->toArray();
    }
}

fomvasss / laravel-slugmaker

Push — master ( 174d79...4b253c )

HasSlugMaker::bootHasSlugMaker() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
