LaTevaWeb\Translatable\Traits\Translatable

Complexity

Total Complexity

27

Size/Duplication

Total Lines	156
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

86.67%

Importance

Changes

0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	create()	0	23	5
A	getAttributeValue()	0	8	2
A	setAttribute()	0	8	3
A	isTranslatableAttribute()	0	4	1
A	getLocale()	0	4	1
A	getTranslatableAttributes()	0	4	2
A	getTranslation()	0	14	2
A	setTranslation()	0	22	2
A	guardAgainstNonTranslatableAttribute()	0	6	2
A	translations()	0	9	1
A	normalizeLocale()	0	14	4
A	getTranslatedLocales()	0	4	1
A	getTranslations()	0	9	1

<?php

namespace LaTevaWeb\Translatable\Traits;

use Illuminate\Database\Eloquent\Relations\MorphToMany;
use Illuminate\Support\Collection;
use Illuminate\Support\Facades\Config;
use LaTevaWeb\Translatable\Exceptions\AttributeIsNotTranslatable;

trait Translatable
{
    public static function create(array $attributes = [])
    {
        $translatables = [];

        foreach ($attributes as $field => $values) {
            if (in_array($field, self::$translatable)) {
                $translatables[$field] = $values;
                unset($attributes[$field]);
            }
        }

        $model = static::query()->create($attributes);

        foreach ($translatables as $field => $values) {
            foreach ($values as $locale => $value) {
                $model->setTranslation($field, $locale, $value);
            }
        }

        $model->save();

        return $model;
    }

    public function getAttributeValue($field)
    {
        if (! $this->isTranslatableAttribute($field)) {
            return parent::getAttributeValue($field);
        }

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

    public function setAttribute($field, $value)
    {
        if (! $this->isTranslatableAttribute($field) || is_array($value)) {
            return parent::setAttribute($field, $value);
        }

        return $this->setTranslation($field, $this->getLocale(), $value);
    }

    public function isTranslatableAttribute(string $field) : bool
    {
        return in_array($field, $this->getTranslatableAttributes());
    }

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

    public function getTranslatableAttributes(): array
    {
        return is_array(self::$translatable) ? self::$translatable : [];
    }

    public function getTranslation(string $field, string $locale, bool $useFallbackLocale = true): ?string
    {
        $locale = $this->normalizeLocale($field, $locale, $useFallbackLocale);

        $translations = $this->getTranslations($field)->all();

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

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

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($field, $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;
    }

    public function setTranslation(string $field, string $locale, $content): self
    {
        $this->guardAgainstNonTranslatableAttribute($field);

        $translation = $this->translations()
            ->where('field', $field)
            ->where('locale', $locale)
            ->first();

        if (! empty($translation)) {
            $translation->content = $content;
            $translation->save();
        } else {
            $this->translations()->create([
                'field' => $field,
                'locale' => $locale,
                'content' => $content,
            ]);
        }

        return $this;
    }

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

    public function translations(): MorphToMany
    {
        return $this->morphToMany(

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

            config('latevaweb-translatable.models.translation'),
            'translatable',
            config('latevaweb-translatable.table_names.translatables'),
            config('latevaweb-translatable.column_names.model_morph_key'),
            'translation_id');
    }

    protected function normalizeLocale(string $field, string $locale, bool $useFallbackLocale) : string
    {
        if (in_array($locale, $this->getTranslatedLocales($field)->all())) {
            return $locale;
        }
        if (! $useFallbackLocale) {
            return $locale;
        }
        if (! is_null($fallbackLocale = Config::get('app.fallback_locale'))) {
            return $fallbackLocale;
        }

        return $locale;
    }

    /**
     * Returns a collection with all locales [ locales ].
     *
     * @param string $field
     * @return Collection
     */
    public function getTranslatedLocales(string $field): Collection
    {
        return $this->getTranslations($field)->keys();
    }

    /**
     * Returns a collection with [ locale => content ].
     *
     * @param string|null $field
     * @return Collection
     */
    public function getTranslations(string $field = null): Collection
    {
        return $this->translations()
            ->where('field', $field)
            ->select('locale', 'content')
            ->get()
            ->keyBy('locale')
            ->pluck('content', 'locale');
    }
}