Spatie\Translatable\HasTranslations

Complexity

Total Complexity

38

Size/Duplication

Total Lines	299
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Importance

Changes

0

21 Methods

Rating	Name	Duplication	Size	Complexity
A	bootHasTranslations()	0	4	1
A	getAttributeValue()	0	8	2
A	setAttribute()	0	11	3
A	translate()	0	4	1
A	getTranslation()	0	14	2
A	getTranslationWithFallback()	0	4	1
A	getTranslationWithoutFallback()	0	4	1
A	getTranslations()	0	16	5
A	setTranslation()	0	24	2
A	setTranslations()	0	10	2
A	forgetTranslation()	0	10	1
A	forgetAllTranslations()	0	8	1
A	getTranslatedLocales()	0	4	1
A	isTranslatableAttribute()	0	4	1
A	hasTranslation()	0	6	2
A	guardAgainstNonTranslatableAttribute()	0	6	2
A	normalizeLocale()	0	20	5
A	getLocale()	0	4	1
A	getTranslatableAttributes()	0	6	2
A	getTranslationsAttribute()	0	8	1
A	getCasts()	0	7	1

<?php

namespace Spatie\Translatable;

use Illuminate\Support\Str;
use Illuminate\Support\Facades\Config;
use Spatie\Translatable\Scopes\WhereScope;
use Spatie\Translatable\Events\TranslationHasBeenSet;
use Spatie\Translatable\Exceptions\AttributeIsNotTranslatable;

trait HasTranslations
{
    /**
     * The "booting" method of the model.
     *
     * @return void
     */
    protected static function bootHasTranslations()
    {
        static::addGlobalScope(new WhereScope);
    }

    /**
     * @param $key
     * @return string
     */
    public function getAttributeValue($key)
    {
        if (! $this->isTranslatableAttribute($key)) {
            return parent::getAttributeValue($key);
        }

        return $this->getTranslation($key, $this->getLocale());
    }

    /**
     * @param $key
     * @param $value
     * @return HasTranslations

The return type HasTranslations is a trait, and thus cannot be used for type-hinting in PHP. Maybe consider adding an interface and use that for type-hinting?

     */
    public function setAttribute($key, $value)
    {
        // Pass arrays and untranslatable attributes to the parent method.
        if (! $this->isTranslatableAttribute($key) || is_array($value)) {
            return parent::setAttribute($key, $value);
        }

        // If the attribute is translatable and not already translated, set a
        // translation for the current app locale.
        return $this->setTranslation($key, $this->getLocale(), $value);
    }

    /**
     * @param string $key
     * @param string $locale
     * @param bool $useFallbackLocale
     * @return string
     */
    public function translate(string $key, string $locale = '', bool $useFallbackLocale = true): string
    {
        return $this->getTranslation($key, $locale, $useFallbackLocale);
    }

    /**
     * @param string $key
     * @param string $locale
     * @param bool $useFallbackLocale
     * @return string
     */
    public function getTranslation(string $key, string $locale, bool $useFallbackLocale = true)
    {
        $locale = $this->normalizeLocale($key, $locale, $useFallbackLocale);

        $translations = $this->getTranslations($key);

        $translation = $translations[$locale] ?? '';

        if ($this->hasGetMutator($key)) {

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

            return $this->mutateAttribute($key, $translation);

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

        }

        return $translation;
    }

    /**
     * @param string $key
     * @param string $locale
     * @return string
     */
    public function getTranslationWithFallback(string $key, string $locale): string
    {
        return $this->getTranslation($key, $locale, true);
    }

    /**
     * @param string $key
     * @param string $locale
     * @return string
     */
    public function getTranslationWithoutFallback(string $key, string $locale)
    {
        return $this->getTranslation($key, $locale, false);
    }

    /**
     * @param string|null $key
     * @return array
     */
    public function getTranslations(string $key = null) : array
    {
        if ($key !== null) {
            $this->guardAgainstNonTranslatableAttribute($key);

            return array_filter(json_decode($this->getAttributes()[$key] ?? '' ?: '{}', true) ?: [], function ($value) {

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

                return $value !== null && $value !== '';
            });
        }

        return array_reduce($this->getTranslatableAttributes(), function ($result, $item) {
            $result[$item] = $this->getTranslations($item);

            return $result;
        });
    }

    /**
     * @param string $key
     * @param string $locale
     * @param $value
     * @return HasTranslations

The return type HasTranslations is a trait, and thus cannot be used for type-hinting in PHP. Maybe consider adding an interface and use that for type-hinting?

     */
    public function setTranslation(string $key, string $locale, $value): self
    {
        $this->guardAgainstNonTranslatableAttribute($key);

        $translations = $this->getTranslations($key);

        $oldValue = $translations[$locale] ?? '';

        if ($this->hasSetMutator($key)) {

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

            $method = 'set'.Str::studly($key).'Attribute';

            $this->{$method}($value, $locale);

            $value = $this->attributes[$key];

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

        }

        $translations[$locale] = $value;

        $this->attributes[$key] = $this->asJson($translations);

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

        event(new TranslationHasBeenSet($this, $key, $locale, $oldValue, $value));

        return $this;
    }

    /**
     * @param string $key
     * @param array $translations
     * @return HasTranslations

The return type HasTranslations is a trait, and thus cannot be used for type-hinting in PHP. Maybe consider adding an interface and use that for type-hinting?

     */
    public function setTranslations(string $key, array $translations): self
    {
        $this->guardAgainstNonTranslatableAttribute($key);

        foreach ($translations as $locale => $translation) {
            $this->setTranslation($key, $locale, $translation);
        }

        return $this;
    }

    /**
     * @param string $key
     * @param string $locale
     * @return HasTranslations

The return type HasTranslations is a trait, and thus cannot be used for type-hinting in PHP. Maybe consider adding an interface and use that for type-hinting?

     */
    public function forgetTranslation(string $key, string $locale): self
    {
        $translations = $this->getTranslations($key);

        unset($translations[$locale]);

        $this->setAttribute($key, $translations);

        return $this;
    }

    /**
     * @param string $locale
     * @return HasTranslations

The return type HasTranslations is a trait, and thus cannot be used for type-hinting in PHP. Maybe consider adding an interface and use that for type-hinting?

     */
    public function forgetAllTranslations(string $locale): self
    {
        collect($this->getTranslatableAttributes())->each(function (string $attribute) use ($locale) {
            $this->forgetTranslation($attribute, $locale);
        });

        return $this;
    }

    /**
     * @param string $key
     * @return array
     */
    public function getTranslatedLocales(string $key) : array
    {
        return array_keys($this->getTranslations($key));
    }

    /**
     * @param string $key
     * @return bool
     */
    public function isTranslatableAttribute(string $key) : bool
    {
        return in_array($key, $this->getTranslatableAttributes());
    }

    /**
     * @param string $key
     * @param string|null $locale
     * @return bool
     */
    public function hasTranslation(string $key, string $locale = null): bool
    {
        $locale = $locale ?: $this->getLocale();

        return isset($this->getTranslations($key)[$locale]);
    }

    /**
     * @param string $key
     */
    protected function guardAgainstNonTranslatableAttribute(string $key)
    {
        if (! $this->isTranslatableAttribute($key)) {
            throw AttributeIsNotTranslatable::make($key, $this);
        }
    }

    /**
     * @param string $key
     * @param string $locale
     * @param bool $useFallbackLocale
     * @return string
     */
    protected function normalizeLocale(string $key, string $locale, bool $useFallbackLocale) : string
    {
        if (in_array($locale, $this->getTranslatedLocales($key))) {
            return $locale;
        }

        if (! $useFallbackLocale) {
            return $locale;
        }

        if (! is_null($fallbackLocale = Config::get('translatable.fallback_locale'))) {
            return $fallbackLocale;
        }

        if (! is_null($fallbackLocale = Config::get('app.fallback_locale'))) {
            return $fallbackLocale;
        }

        return $locale;
    }

    /**
     * @return string
     */
    protected function getLocale() : string
    {
        return Config::get('app.locale');
    }

    /**
     * @return array
     */
    public function getTranslatableAttributes() : array
    {
        return is_array($this->translatable)

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

            ? $this->translatable
            : [];
    }

    /**
     * @return array
     */
    public function getTranslationsAttribute(): array
    {
        return collect($this->getTranslatableAttributes())
            ->mapWithKeys(function (string $key) {
                return [$key => $this->getTranslations($key)];
            })
            ->toArray();
    }

    /**
     * @return array
     */
    public function getCasts() : array
    {
        return array_merge(
            parent::getCasts(),
            array_fill_keys($this->getTranslatableAttributes(), 'array')
        );
    }
}