Thinktomorrow\Chief\Urls\UrlSlugFields

Complexity

Total Complexity

11

Size/Duplication

Total Lines	84
Duplicated Lines	0 %

Test Coverage

Coverage

82.5%

Importance

Changes	4
Bugs	1	Features	0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	fromModel()	0	7	1
A	fillWithExistingValues()	0	15	3
A	redirectsFromModel()	0	16	2
A	initEmptyFields()	0	13	2
A	toJson()	0	3	1
A	toArray()	0	9	2

<?php

namespace Thinktomorrow\Chief\Urls;

use Thinktomorrow\Chief\Fields\Fields;
use Thinktomorrow\Chief\Urls\ProvidesUrl\ProvidesUrl;

class UrlSlugFields extends Fields
{
    public static function fromModel(ProvidesUrl $model)
    {
        $fields = self::initEmptyFields($model->availableLocales(), $model);

The method availableLocales() does not exist on Thinktomorrow\Chief\Urls\ProvidesUrl\ProvidesUrl. Since it exists in all sub-types, consider adding an abstract or default implementation to Thinktomorrow\Chief\Urls\ProvidesUrl\ProvidesUrl.

        self::fillWithExistingValues($model, $fields);

        return $fields;
    }

    public static function redirectsFromModel(ProvidesUrl $model)
    {
        $records = MemoizedUrlRecord::getByModel($model)->reject(function ($record) {
            return !$record->isRedirect();
        })->sortByDesc('created_at');

        $fields = new static([]);

        foreach ($records as $record) {
            $key = 'redirects-'.$record->locale.'-'.$record->slug;
            $fields[$key] = UrlSlugField::make($key)
                ->setUrlRecord($record)
                ->setFullUrl($model->resolveUrl($record->locale, $record->slug));
        }

        return $fields;
    }

    public function toJson(): string
    {
        return json_encode($this->toArray());
    }

    public function toArray(): array
    {
        $array = [];

        foreach ($this->all() as $field) {
            $array[] = $field->toArray();
        }

        return $array;
    }

    /**
     * @param array $locales
     * @param ProvidesUrl $model
     * @return UrlSlugFields
     */
    private static function initEmptyFields(array $locales, ProvidesUrl $model): self
    {
        $fields = new static([]);

        foreach ($locales as $locale) {
            $fields['url-slugs.' . $locale] = UrlSlugField::make('url-slugs.' . $locale)
                                                ->setBaseUrlSegment($model->baseUrlSegment($locale))
                                                ->prepend($model->resolveUrl($locale, $model->baseUrlSegment($locale)) .'/')

The method prepend() does not exist on Thinktomorrow\Chief\Urls\UrlSlugField. Since you implemented __call, consider adding a @method annotation.

                                                ->name('url-slugs[' . $locale . ']')
                                                ->label($locale);

The method label() does not exist on Thinktomorrow\Chief\Urls\UrlSlugField. Since you implemented __call, consider adding a @method annotation.

        }

        return $fields;
    }

    /**
     * @param ProvidesUrl $model
     * @param $fields
     */
    private static function fillWithExistingValues(ProvidesUrl $model, self $fields): void
    {
        $records = UrlRecord::getByModel($model)->reject(function ($record) {
            return $record->isRedirect();
        })->sortBy('locale');

        foreach ($records as $record) {
            if (!isset($fields['url-slugs.'.$record->locale])) {
                continue;
            }

            $fields['url-slugs.'.$record->locale]
                ->setUrlRecord($record)

The method setUrlRecord() does not exist on null.

                ->setBaseUrlSegment($model->baseUrlSegment($record->locale))
                ->prepend($model->resolveUrl($record->locale, $model->baseUrlSegment($record->locale)) .'/');
        }
    }
}