BaseCommand::ranLocales() - Code Metrics - Inspection of "[10.x] `laravel-lang/lang` v10 support" - andrey-helldar/laravel-lang-publisher - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — main (#107)

by Andrey

created 2021-05-20 18:12 UTC

BaseCommand::ranLocales() A

↳ Parent: BaseCommand

Complexity

Conditions	2
Paths	2

Size

Total Lines	11
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	6
CRAP Score	2

Importance

Changes

Metric	Value
cc	2
eloc	6
nc	2
nop	1
dl	0
loc	11
ccs	6
cts	6
cp	1
crap	2
rs	10
c	0
b	0
f	0

<?php

namespace Helldar\LaravelLangPublisher\Console;

use Helldar\LaravelLangPublisher\Concerns\Containable;
use Helldar\LaravelLangPublisher\Concerns\Logger;
use Helldar\LaravelLangPublisher\Concerns\Pathable;
use Helldar\LaravelLangPublisher\Constants\Locales as LocalesList;
use Helldar\LaravelLangPublisher\Contracts\Actionable;
use Helldar\LaravelLangPublisher\Contracts\Plugin;
use Helldar\LaravelLangPublisher\Contracts\Processor;
use Helldar\LaravelLangPublisher\Facades\Config;
use Helldar\LaravelLangPublisher\Facades\Info;
use Helldar\LaravelLangPublisher\Facades\Locales;
use Helldar\LaravelLangPublisher\Facades\Packages;
use Helldar\LaravelLangPublisher\Facades\Validator;
use Helldar\LaravelLangPublisher\Services\Command\Locales as LocalesSupport;
use Helldar\LaravelLangPublisher\Support\Info as InfoSupport;
use Helldar\Support\Facades\Helpers\Arr;
use Helldar\Support\Facades\Helpers\Filesystem\File;
use Helldar\Support\Facades\Helpers\Str;
use Illuminate\Console\Command;

abstract class BaseCommand extends Command
{
    use Containable;
    use Logger;
    use Pathable;

    protected $action;

    protected $locales_length = 0;

    protected $files_length = 0;

    protected $files;

    protected $locales;

    protected $plugins;

    protected $processed = [];

    public function handle()
    {
        $this->setLogger();
        $this->start();
        $this->clean();
        $this->ran();
        $this->end();
    }

    abstract protected function processor(?string $filename): Processor;

    protected function ran(): void
    {
        $this->log('Starting processing of the package list...');

        foreach ($this->packages() as $package) {
            $this->log('Plugins handling:', $package);

            $this->validatePackage($package);

            $this->ranLocales($package);
        }
    }

    protected function ranLocales(string $package): void
    {
        $this->log('Starting processing of the locales list for the', $package, 'package...');

        foreach ($this->locales() as $locale) {
            $this->log('Localization handling:', $locale);

            $this->validateLocale($locale);

            $this->ranFiles($package, $locale);
            $this->ranPlugins($package, $locale);
        }
    }

    protected function ranFiles(string $package, string $locale): void
    {
        $this->log('Starting processing of the files for the', $package, 'package and', $locale, 'localization...');

        foreach ($this->files($package) as $filename) {
            $this->log('Processing the localization file:', $filename);

            $this->processing($locale, $filename, $package);

            $status = $this->process($package, $locale, $filename);

            $this->pushProcessed($filename);

            $this->processed($locale, $filename, $status, $package);
        }
    }

    protected function ranPlugins(string $package, string $locale): void
    {
        $this->log('Starting processing of plugin files for the', $package, 'package and', $locale, 'localization...');

        foreach ($this->plugins() as $plugin) {
            foreach ($plugin->source() as $source) {
                $target = $plugin->targetPath($locale, $source);

                $this->processing($locale, $source, $package);

                $status = $this->process($package, $locale, $source, $target);

                $this->pushProcessed($target);

                $this->processed($locale, $source, $status, $package);
            }
        }
    }

    protected function process(?string $package, ?string $locale, ?string $source, string $target = null): string
    {
        $this->log('Launching the processor for localization:', $locale, ',', $source);

        return $this->processor($source)
            ->force($this->hasForce() || $this->hasProcessed($target))
            ->whenPackage($package)
            ->whenLocale($locale)
            ->whenSourceFilename($source, $this->hasInline())
            ->whenTargetFilename($target ?: $source)
            ->run();
    }

    protected function locales(): array
    {
        $this->log('Getting a list of localizations...');

        if (! empty($this->locales)) {
            return $this->locales;
        }

        return $this->locales = LocalesSupport::make($this->input, $this->output, $this->action(), $this->targetLocales())->get();
    }

    protected function targetLocales(): array
    {
        $this->log('Getting a list of installed localizations...');

        return Locales::installed();
    }

    protected function packages(): array
    {
        $this->log('Getting a list of packages available for processing...');

        return Packages::get();
    }

    protected function files(string $package): array
    {
        $this->log('Getting a list of files for the ', $package, 'package...');

        if ($this->files[$package] ?? false) {
            return $this->files[$package];
        }

        $path = $this->pathSource($package, LocalesList::ENGLISH);

        return $this->files[$package] = File::names($path, static function ($filename) {
            return ! Str::contains($filename, 'inline');
        });
    }

    /**
     * @return array|\Helldar\LaravelLangPublisher\Plugins\Plugin[]
     */
    protected function plugins(): array
    {
        if (! empty($this->plugins)) {
            return $this->plugins;
        }

        $plugins = array_map(static function ($plugin) {
            /* @var \Helldar\LaravelLangPublisher\Plugins\Plugin $plugin */
            return $plugin::make();
        }, $this->getPlugins());

        $plugins = array_filter($plugins, static function (Plugin $plugin) {
            return $plugin->has();
        });

        return $this->plugins = $plugins;
    }

    protected function start(): void
    {
        $this->log('Running the console command:', parent::class);

        $action = $this->action()->present(true);

        $this->info($action . ' localizations...');
    }

    protected function end(): void
    {
        $this->log('Completing the execution of the console command...');

        $action = $this->action()->past();

        $this->info('Localizations have ben successfully ' . $action . '.');
    }

    protected function processing(string $locale, string $filename, string $package = null): void
    {
        $this->log('Displaying a message about the start of file processing: locale is', $locale, ', filename is', $filename, ', package is', $package . '...');

        $message = $this->message($locale, $filename, $package)->start();

        $this->output->write($message);
    }

    protected function processed(string $locale, string $filename, string $status, string $package = null): void
    {
        $this->log('Displaying a message about the finish of file processing: locale is', $locale, ', filename is', $filename, ', package is', $package . '...');

        $message = $this->message($locale, $filename, $package)->finish($status);

        $this->output->writeln($message);
    }

    protected function message(string $locale, string $filename, string $package = null): InfoSupport
    {
        $this->log('Preparing an object for displaying a message: locale is', $locale, ', filename is', $filename, ', package is', $package . '...');

        return Info::same()
            ->package($package)
            ->locale($locale, $this->localesLength())
            ->filename($filename, $this->filesLength());
    }

    protected function localesLength(): int
    {
        $this->log('Getting the maximum length of a localization string...');

        if ($this->locales_length > 0) {
            return $this->locales_length;
        }

        $this->log('Calculating the maximum length of a localization string...');

        return $this->locales_length = Arr::longestStringLength($this->locales());
    }

    protected function filesLength(): int
    {
        $this->log('Getting the maximum length of a filenames...');

        if ($this->files_length > 0) {
            return $this->files_length;
        }

        $this->log('Calculating the maximum length of a filenames...');

        $files = [];

        foreach ($this->packages() as $package) {
            $files = array_merge($files, $this->files($package));
        }

        return $this->files_length = Arr::longestStringLength(array_unique($files));
    }

    protected function hasInline(): bool
    {
        $this->log('Getting a use case for a validation file.');

        return Config::hasInline();
    }

    protected function getPlugins(): array
    {
        $this->log('Getting a list of plugins...');

        return Config::plugins();
    }

    protected function action(): Actionable
    {
        $this->log('Getting the action...');

        return $this->container($this->action);
    }

    protected function pushProcessed(?string $filename): void
    {
        $this->log('Add a link to the processed file to the cache:', $filename);

        if ($filename && ! $this->hasProcessed($filename)) {
            $this->processed[] = $filename;
        }
    }

    protected function hasProcessed(?string $filename): bool
    {
        $this->log('Check if the file was processed earlier:', $filename);

        return $filename && in_array($filename, $this->processed, true);
    }

    protected function hasForce(): bool
    {
        $this->log('Getting the value of the "force" option...');

        return $this->boolOption('force');
    }

    protected function hasFull(): bool
    {
        $this->log('Getting the value of the "full" option...');

        return $this->boolOption('full');
    }

    protected function boolOption(string $key): bool
    {
        $this->log('Getting the value of the "', $key, '" option...');

        return $this->hasOption($key) && $this->option($key);
    }

    protected function validateLocale(string $locale): void
    {
        $this->log('Calling the localization validation method: ', $locale, '...');

        Validator::locale($locale);
    }

    protected function validatePackage(string $package): void
    {
        $this->log('Calling the package validation method: ', $package, '...');

        Validator::package($package);
    }

    protected function clean(): void
    {
        $this->log('Clear the variable from the saved localizations...');

        $this->locales = null;
    }
}


1		<?php
2
3		namespace Helldar\LaravelLangPublisher\Console;
4
5		use Helldar\LaravelLangPublisher\Concerns\Containable;
6		use Helldar\LaravelLangPublisher\Concerns\Logger;
7		use Helldar\LaravelLangPublisher\Concerns\Pathable;
8		use Helldar\LaravelLangPublisher\Constants\Locales as LocalesList;
9		use Helldar\LaravelLangPublisher\Contracts\Actionable;
10		use Helldar\LaravelLangPublisher\Contracts\Plugin;
11		use Helldar\LaravelLangPublisher\Contracts\Processor;
12		use Helldar\LaravelLangPublisher\Facades\Config;
13		use Helldar\LaravelLangPublisher\Facades\Info;
14		use Helldar\LaravelLangPublisher\Facades\Locales;
15		use Helldar\LaravelLangPublisher\Facades\Packages;
16		use Helldar\LaravelLangPublisher\Facades\Validator;
17		use Helldar\LaravelLangPublisher\Services\Command\Locales as LocalesSupport;
18		use Helldar\LaravelLangPublisher\Support\Info as InfoSupport;
19		use Helldar\Support\Facades\Helpers\Arr;
20		use Helldar\Support\Facades\Helpers\Filesystem\File;
21		use Helldar\Support\Facades\Helpers\Str;
22		use Illuminate\Console\Command;
23
24		abstract class BaseCommand extends Command
25		{
26		use Containable;
27		use Logger;
28		use Pathable;
29
30		protected $action;
31
32		protected $locales_length = 0;
33
34		protected $files_length = 0;
35
36		protected $files;
37
38		protected $locales;
39	18
40		protected $plugins;
41	18
42	18	protected $processed = [];
43	18
44	18	public function handle()
45	15	{
46	15	$this->setLogger();
47		$this->start();
48		$this->clean();
49		$this->ran();
50	17	$this->end();
51		}
52	17
53		abstract protected function processor(?string $filename): Processor;
54	17
55	17	protected function ran(): void
56		{
57	17	$this->log('Starting processing of the package list...');
58
59	15	foreach ($this->packages() as $package) {
60		$this->log('Plugins handling:', $package);
61	14
62		$this->validatePackage($package);
63	15
64		$this->ranLocales($package);
65	15	}
66		}
67	15
68	15	protected function ranLocales(string $package): void
69		{
70	15	$this->log('Starting processing of the locales list for the', $package, 'package...');
71
72	14	foreach ($this->locales() as $locale) {
73		$this->log('Localization handling:', $locale);
74	14
75		$this->validateLocale($locale);
76	14
77		$this->ranFiles($package, $locale);
78	14	$this->ranPlugins($package, $locale);
79		}
80	14	}
81	14
82		protected function ranFiles(string $package, string $locale): void
83	14	{
84		$this->log('Starting processing of the files for the', $package, 'package and', $locale, 'localization...');
85	14
86		foreach ($this->files($package) as $filename) {
87	14	$this->log('Processing the localization file:', $filename);
88
89	14	$this->processing($locale, $filename, $package);
90
91	15	$status = $this->process($package, $locale, $filename);
92
93	15	$this->pushProcessed($filename);
94
95	15	$this->processed($locale, $filename, $status, $package);
96	15	}
97	15	}
98	15
99	15	protected function ranPlugins(string $package, string $locale): void
100	15	{
101		$this->log('Starting processing of plugin files for the', $package, 'package and', $locale, 'localization...');
102
103	15	foreach ($this->plugins() as $plugin) {
104		foreach ($plugin->source() as $source) {
105	15	$target = $plugin->targetPath($locale, $source);
106
107	15	$this->processing($locale, $source, $package);
108	14
109		$status = $this->process($package, $locale, $source, $target);
110
111	15	$this->pushProcessed($target);
112
113		$this->processed($locale, $source, $status, $package);
114	7	}
115		}
116	7	}
117
118	7	protected function process(?string $package, ?string $locale, ?string $source, string $target = null): string
119		{
120		$this->log('Launching the processor for localization:', $locale, ',', $source);
121	18
122		return $this->processor($source)
123	18	->force($this->hasForce() \|\| $this->hasProcessed($target))
124		->whenPackage($package)
125	18	->whenLocale($locale)
126		->whenSourceFilename($source, $this->hasInline())
127		->whenTargetFilename($target ?: $source)
128	15	->run();
129		}
130	15
131		protected function locales(): array
132	15	{
133	14	$this->log('Getting a list of localizations...');
134
135		if (! empty($this->locales)) {
136	15	return $this->locales;
137		}
138	15
139	15	return $this->locales = LocalesSupport::make($this->input, $this->output, $this->action(), $this->targetLocales())->get();
140	15	}
141
142		protected function targetLocales(): array
143	18	{
144		$this->log('Getting a list of installed localizations...');
145	18
146		return Locales::installed();
147	18	}
148
149	18	protected function packages(): array
150	18	{
151		$this->log('Getting a list of packages available for processing...');
152	15
153		return Packages::get();
154	15	}
155
156	15	protected function files(string $package): array
157		{
158	15	$this->log('Getting a list of files for the ', $package, 'package...');
159	15
160		if ($this->files[$package] ?? false) {
161	15	return $this->files[$package];
162		}
163	15
164		$path = $this->pathSource($package, LocalesList::ENGLISH);
165	15
166		return $this->files[$package] = File::names($path, static function ($filename) {
167	15	return ! Str::contains($filename, 'inline');
168	15	});
169		}
170	15
171		/**
172	15	* @return array\|\Helldar\LaravelLangPublisher\Plugins\Plugin[]
173		*/
174	15	protected function plugins(): array
175		{
176	15	if (! empty($this->plugins)) {
177	15	return $this->plugins;
178		}
179	15
180		$plugins = array_map(static function ($plugin) {
181	15	/* @var \Helldar\LaravelLangPublisher\Plugins\Plugin $plugin */
182		return $plugin::make();
183	15	}, $this->getPlugins());
184	15
185	15	$plugins = array_filter($plugins, static function (Plugin $plugin) {
186	15	return $plugin->has();
187		});
188
189	15	return $this->plugins = $plugins;
190		}
191	15
192		protected function start(): void
193	15	{
194	15	$this->log('Running the console command:', parent::class);
195
196		$action = $this->action()->present(true);
197	15
198		$this->info($action . ' localizations...');
199	15	}
200
201		protected function end(): void
202	15	{
203		$this->log('Completing the execution of the console command...');
204	15
205		$action = $this->action()->past();
206	15
207	15	$this->info('Localizations have ben successfully ' . $action . '.');
208		}
209
210	15	protected function processing(string $locale, string $filename, string $package = null): void
211		{
212	15	$this->log('Displaying a message about the start of file processing: locale is', $locale, ', filename is', $filename, ', package is', $package . '...');
213
214	15	$message = $this->message($locale, $filename, $package)->start();
215	15
216		$this->output->write($message);
217		}
218	15
219		protected function processed(string $locale, string $filename, string $status, string $package = null): void
220		{
221	15	$this->log('Displaying a message about the finish of file processing: locale is', $locale, ', filename is', $filename, ', package is', $package . '...');
222
223	15	$message = $this->message($locale, $filename, $package)->finish($status);
224
225	15	$this->output->writeln($message);
226		}
227
228	18	protected function message(string $locale, string $filename, string $package = null): InfoSupport
229		{
230	18	$this->log('Preparing an object for displaying a message: locale is', $locale, ', filename is', $filename, ', package is', $package . '...');
231
232	18	return Info::same()
233		->package($package)
234		->locale($locale, $this->localesLength())
235	14	->filename($filename, $this->filesLength());
236		}
237	14
238		protected function localesLength(): int
239	14	{
240		$this->log('Getting the maximum length of a localization string...');
241
242	2	if ($this->locales_length > 0) {
243		return $this->locales_length;
244	2	}
245
246	2	$this->log('Calculating the maximum length of a localization string...');
247
248		return $this->locales_length = Arr::longestStringLength($this->locales());
249	14	}
250
251	14	protected function filesLength(): int
252		{
253	14	$this->log('Getting the maximum length of a filenames...');
254
255		if ($this->files_length > 0) {
256	16	return $this->files_length;
257		}
258	16
259		$this->log('Calculating the maximum length of a filenames...');
260	16
261	15	$files = [];
262
263	17	foreach ($this->packages() as $package) {
264		$files = array_merge($files, $this->files($package));
265	17	}
266
267	17	return $this->files_length = Arr::longestStringLength(array_unique($files));
268	15	}
269
270	18	protected function hasInline(): bool
271		{
272	18	$this->log('Getting a use case for a validation file.');
273
274	18	return Config::hasInline();
275	18	}
276
277		protected function getPlugins(): array
278		{
279		$this->log('Getting a list of plugins...');
280
281		return Config::plugins();
282		}
283
284		protected function action(): Actionable
285		{
286		$this->log('Getting the action...');
287
288		return $this->container($this->action);
289		}
290
291		protected function pushProcessed(?string $filename): void
292		{
293		$this->log('Add a link to the processed file to the cache:', $filename);
294
295		if ($filename && ! $this->hasProcessed($filename)) {
296		$this->processed[] = $filename;
297		}
298		}
299
300		protected function hasProcessed(?string $filename): bool
301		{
302		$this->log('Check if the file was processed earlier:', $filename);
303
304		return $filename && in_array($filename, $this->processed, true);
305		}
306
307		protected function hasForce(): bool
308		{
309		$this->log('Getting the value of the "force" option...');
310
311		return $this->boolOption('force');
312		}
313
314		protected function hasFull(): bool
315		{
316		$this->log('Getting the value of the "full" option...');
317
318		return $this->boolOption('full');
319		}
320
321		protected function boolOption(string $key): bool
322		{
323		$this->log('Getting the value of the "', $key, '" option...');
324
325		return $this->hasOption($key) && $this->option($key);
326		}
327
328		protected function validateLocale(string $locale): void
329		{
330		$this->log('Calling the localization validation method: ', $locale, '...');
331
332		Validator::locale($locale);
333		}
334
335		protected function validatePackage(string $package): void
336		{
337		$this->log('Calling the package validation method: ', $package, '...');
338
339		Validator::package($package);
340		}
341
342		protected function clean(): void
343		{
344		$this->log('Clear the variable from the saved localizations...');
345
346		$this->locales = null;
347		}
348		}
349

andrey-helldar / laravel-lang-publisher

Pull Request — main (#107)

BaseCommand::ranLocales() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like