Helldar\LaravelLangPublisher\Services\Comparators\Comparator

Complexity

Total Complexity

18

Size/Duplication

Total Lines	124
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	0	Features	0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	source()	0	5	1
A	findNotReplace()	0	7	2
A	getFallbackValue()	0	5	2
A	sort()	0	5	1
A	ranExcludes()	0	6	2
A	key()	0	5	1
A	handle()	0	5	2
A	toArray()	0	11	1
A	extractExcludes()	0	8	1
A	splitNotSortable()	0	8	2
A	target()	0	5	1
A	prepareExcludes()	0	5	1
A	full()	0	5	1

<?php

namespace Helldar\LaravelLangPublisher\Services\Comparators;

use Helldar\LaravelLangPublisher\Concerns\Logger;
use Helldar\LaravelLangPublisher\Concerns\Reservation;
use Helldar\LaravelLangPublisher\Contracts\Comparator as Contract;
use Helldar\Support\Concerns\Makeable;
use Helldar\Support\Facades\Helpers\Arr;

abstract class Comparator implements Contract
{
    use Logger;

The trait Helldar\LaravelLangPublisher\Concerns\Logger requires the property $output which is not provided by Helldar\LaravelLangPublisher\Services\Comparators\Comparator.

    use Makeable;
    use Reservation;

    protected $key;

    protected $full = false;

    protected $source;

    protected $target;

    protected $excludes = [];

    protected $not_replace = [];

    public function handle(): array
    {
        $this->log('Merging source and target arrays...');

        return $this->full ? $this->source : array_merge($this->target, $this->source, $this->not_replace);
    }

    public function key(string $key): Contract
    {
        $this->key = $key;

        return $this;
    }

    public function full(bool $full): Contract
    {
        $this->full = $full;

        return $this;
    }

    public function source(array $array): Contract
    {
        $this->source = $array;

        return $this;
    }

    public function target(array $array): Contract
    {
        $this->target = $array;

        return $this;
    }

    public function toArray(): array
    {
        $this->findNotReplace();
        $this->splitNotSortable();

        $array    = $this->sort($this->handle());
        $excludes = $this->sort($this->excludes);

        $this->log('Merging the main array with excluded data...');

        return array_merge($array, $excludes);
    }

    protected function splitNotSortable(): void
    {
        $this->log('Splitting main arrays into excludes...');

        if (! empty($this->excludes)) {
            $this->prepareExcludes();
            $this->ranExcludes();
            $this->extractExcludes();
        }
    }

    protected function findNotReplace(): void
    {
        if ($this->full) {
            return;
        }

        $this->not_replace = $this->reserved($this->target, $this->key);
    }

    protected function ranExcludes(): void
    {
        $this->log('Retrieving values from arrays...');

        foreach ($this->excludes as $key => &$value) {
            $value = $this->getFallbackValue($this->source, $this->target, $key);
        }
    }

    protected function extractExcludes(): void
    {
        $this->log('Extracting extended data from source and target arrays ...');

        $keys = array_keys($this->excludes);

        $this->source = Arr::except($this->source, $keys);
        $this->target = Arr::except($this->target, $keys);
    }

    protected function getFallbackValue(array $source, array $target, string $key): array
    {
        $this->log('Retrieving values from arrays by the "' . $key . '" key...');

        return Arr::get($target, $key) ?: Arr::get($source, $key, []);
    }

    protected function sort(array $array): array
    {
        $this->log('Sorting array...');

        return Arr::ksort($array);
    }

    protected function prepareExcludes(): void
    {
        $this->log('Exchanges all keys with their associated values in an array...');

        $this->excludes = array_flip($this->excludes);
    }
}