SlugMakerTrait::scopeGetBySlugs() - Code Metrics - Inspection of "Add new scope in model trait" - fomvasss/laravel-slugmaker - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( f098ed...4b87ed )

by Vasyl
created 2017-12-03 23:14 UTC
SlugMakerTrait::scopeGetBySlugs() A

↳ Parent: SlugMakerTrait
Complexity

Conditions	1
Paths	1
Size

Total Lines	3
Code Lines	1
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	1
eloc	1
nc	1
nop	2
dl	0
loc	3
rs	10
c	0
b	0
f	0
<?php

namespace Fomvasss\SlugMaker;

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

trait SlugMakerTrait
{
    protected $slugOptions;

    private $slugField = 'name';

    private $relatedName = 'slugable';

    private $slugModel = \Fomvasss\SlugMaker\Models\Slug::class;

    /**
     * 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()
    {
        $this->setConfig();

        return $this->morphOne($this->slugModel, $this->relatedName);
        return $this->/** @scrutinizer ignore-call */ morphOne($this->slugModel, $this->relatedName);
    }

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

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

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

    protected function setConfig()
    {
        $config = config('slugmaker');
        $config = /** @scrutinizer ignore-call */ config('slugmaker');

        foreach ($config as $name => $value) {
            $name = camel_case($name);
            $this->$name = $value;
        }
    }

    /**
     * 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)
    {
        $this->setConfig();

        if ($this->slug) {

            //$this->slug()->updateOrCreate(['name' => $this->slug->name], [$this->slugField => $slug]);
            $this->slug()->update([$this->slugField => $slug]);
        } else {
            $this->slug()->create([$this->slugField => $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 substr($slugSourceString, 0, $this->slugOptions->maximumLength);

        }

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

        return substr($slugSourceString, 0, $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) $this->slugModel::where($this->slugField, $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()
    {
        $this->setConfig();

        if ($this->slug) {

            return $this->slug->{$this->slugField};
        }

        return '';
    }

    /**
     * Models by slugs.
     *
     * @param $query
     * @param string $slug
     * @return mixed
     */
    public function scopeBySlugs($query, $slug)
    {
        $this->setConfig();

        $slugs = is_array($slug) ? $slug : [$slug];

        return $query->whereHas('slug', function ($q) use ($slugs) {
            $q->whereIn($this->slugField, $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 $slug
     * @return mixed
     */
    public function scopeGetBySlugs($query, $slug)
    {
        return $this->scopeBySlugs($query, $slug)->get();
    }
}

fomvasss / laravel-slugmaker

Push — master ( f098ed...4b87ed )

SlugMakerTrait::scopeGetBySlugs() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
