Helldar\LaravelLangPublisher\Services\Processors\Processor

Complexity

Total Complexity

29

Size/Duplication

Total Lines	200
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	4
Bugs	0	Features	0

20 Methods

Rating	Name	Duplication	Size	Complexity
A	package()	0	5	1
A	locale()	0	5	1
A	full()	0	5	1
A	main()	0	3	1
A	force()	0	5	1
A	store()	0	5	1
A	manager()	0	5	1
A	sourceFilename()	0	5	1
A	setTargetPath()	0	5	1
A	doesntExists()	0	5	1
A	whenPackage()	0	7	2
A	setSourcePath()	0	21	5
A	compare()	0	11	1
A	setMainPath()	0	10	2
A	whenSourceFilename()	0	7	2
A	whenLocale()	0	7	2
A	targetFilename()	0	6	1
A	process()	0	10	1
A	whenTargetFilename()	0	7	2
A	load()	0	5	1

<?php

namespace Helldar\LaravelLangPublisher\Services\Processors;

use Helldar\LaravelLangPublisher\Concerns\Containable;
use Helldar\LaravelLangPublisher\Concerns\Contains;
use Helldar\LaravelLangPublisher\Concerns\Logger;
use Helldar\LaravelLangPublisher\Concerns\Pathable;
use Helldar\LaravelLangPublisher\Constants\Locales;
use Helldar\LaravelLangPublisher\Contracts\Processor as Contract;
use Helldar\LaravelLangPublisher\Services\Comparators\Manage;
use Helldar\LaravelLangPublisher\Services\Filesystem\Manager;
use Helldar\Support\Concerns\Makeable;
use Helldar\Support\Facades\Helpers\Filesystem\File;

abstract class Processor implements Contract
{
    use Containable;
    use Contains;
    use Logger;

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

    use Makeable;
    use Pathable;

    protected $package;

    protected $locale;

    protected $source_path;

    protected $target_path;

    protected $main_path;

    protected $force;

    protected $full = false;

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

        return $this;
    }

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

        return $this;
    }

    public function sourceFilename(string $filename, bool $is_inline = true): Contract
    {
        $this->setSourcePath($filename, $is_inline);

        return $this;
    }

    public function targetFilename(string $filename): Contract
    {
        $this->setTargetPath($filename);
        $this->setMainPath($filename);

        return $this;
    }

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

        return $this;
    }

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

        return $this;
    }

    public function whenPackage(?string $package): Contract
    {
        if ($package) {
            $this->package($package);
        }

        return $this;
    }

    public function whenLocale(?string $locale): Contract
    {
        if ($locale) {
            $this->locale($locale);
        }

        return $this;
    }

    public function whenSourceFilename(?string $filename, bool $is_inline = true): Contract
    {
        if ($filename) {
            $this->sourceFilename($filename, $is_inline);
        }

        return $this;
    }

    public function whenTargetFilename(?string $filename): Contract
    {
        if ($filename) {
            $this->targetFilename($filename);
        }

        return $this;
    }

    protected function main(): void
    {
        $this->process($this->source_path, $this->target_path, $this->main_path);
    }

    protected function process(string $source_path, string $target_path, string $main_path = null): void
    {
        $this->log('The process of processing a file from', $source_path, 'to', $target_path, 'has begun.');

        $source = $this->load($source_path, $main_path);
        $target = $this->load($target_path);

        $result = $this->compare($source, $target);

        $this->store($target_path, $result);
    }

    protected function setSourcePath(string $filename, bool $is_inline): void
    {
        $this->log('Setting the path to the source file:', $filename);

        $path = $this->isJson($filename)
            ? $this->pathSource($this->package, Locales::ENGLISH)
            : $this->pathSource($this->package, $this->locale);

        if ($is_inline) {
            $this->log('The', $filename, '(is inline: ', $is_inline, ')', 'file is a collection of inline messages...');

            $directory = $this->pathDirectory($filename);
            $name      = $this->pathFilename($filename);
            $extension = $this->pathExtension($filename);

            $inline_file = $directory . '/' . $name . '-inline.' . $extension;
        }

        $this->source_path = $is_inline && File::exists($path . '/' . $inline_file)

The variable $inline_file does not seem to be defined for all execution paths leading up to this point.

            ? $path . '/' . $inline_file
            : $path . '/' . $filename;
    }

    protected function setTargetPath(string $filename): void
    {
        $this->log('Setting the path to the target file:', $filename);

        $this->target_path = $this->pathTargetFull($this->locale, $filename);
    }

    protected function setMainPath(string $filename): void
    {
        $this->log('Setting the path to the json main file with', $filename);

        if ($this->isJson($filename)) {
            $path = $this->pathSource($this->package, $this->locale);

            $file = $this->locale . '.json';

            $this->main_path = $path . '/' . $file;
        }
    }

    protected function compare(array $source, array $target): array
    {
        $this->log('Find an object and perform object comparison.');

        return Manage::make()
            ->filename($this->source_path)
            ->full($this->full)
            ->source($source)
            ->target($target)
            ->find()
            ->toArray();
    }

    protected function load(string $path, string $filename = null): array
    {
        $this->log('Loading an array:', $path, $filename);

        return $this->manager()->load($path, $filename);
    }

    protected function store(string $path, array $content): void
    {
        $this->log('Saving an array to a file:', $path);

        $this->manager()->store($path, $content);
    }

    protected function manager(): Manager
    {
        $this->log('Getting a comparison object...');

        return $this->container(Manager::class);
    }

    protected function doesntExists(): bool
    {
        $this->log('Checking for the existence of a file:', $this->target_path);

        return ! File::exists($this->target_path);
    }
}