BaseCommand::ranPackages() - Code Metrics - Inspection of "Added line break" - andrey-helldar/laravel-lang-publisher - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — features/split-packages ( 745907...9ff8f9 )

by Andrey

created 2021-05-20 18:09 UTC

BaseCommand::ranPackages() A

↳ Parent: BaseCommand

Complexity

Conditions	4
Paths	4

Size

Total Lines	25
Code Lines	14

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	4
eloc	14
nc	4
nop	2
dl	0
loc	25
rs	9.7998
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
40			protected $plugins;
41
42			protected $processed = [];
43
44			public function handle()
45			{
46			$this->setLogger();
47			$this->start();
48			$this->clean();
49			$this->ran();
50			$this->end();
51			}
52
53			abstract protected function processor(?string $filename): Processor;
54
55			protected function ran(): void
56			{
57			$this->log('Starting processing of the package list...');
58
59			foreach ($this->packages() as $package) {
60			$this->log('Plugins handling:', $package);
61
62			$this->validatePackage($package);
63
64			$this->ranLocales($package);
65			}
66			}
67
68			protected function ranLocales(string $package): void
69			{
70			$this->log('Starting processing of the locales list for the', $package, 'package...');
71
72			foreach ($this->locales() as $locale) {
73			$this->log('Localization handling:', $locale);
74
75			$this->validateLocale($locale);
76
77			$this->ranFiles($package, $locale);
78			$this->ranPlugins($package, $locale);
79			}
80			}
81
82			protected function ranFiles(string $package, string $locale): void
83			{
84			$this->log('Starting processing of the files for the', $package, 'package and', $locale, 'localization...');
85
86			foreach ($this->files($package) as $filename) {
87			$this->log('Processing the localization file:', $filename);
88
89			$this->processing($locale, $filename, $package);
90
91			$status = $this->process($package, $locale, $filename);
92
93			$this->pushProcessed($filename);
94
95			$this->processed($locale, $filename, $status, $package);
96			}
97			}
98
99			protected function ranPlugins(string $package, string $locale): void
100			{
101			$this->log('Starting processing of plugin files for the', $package, 'package and', $locale, 'localization...');
102
103			foreach ($this->plugins() as $plugin) {
104			foreach ($plugin->source() as $source) {
105			$target = $plugin->targetPath($locale, $source);
106
107			$this->processing($locale, $source, $package);
108
109			$status = $this->process($package, $locale, $source, $target);
110
111			$this->pushProcessed($target);
112
113			$this->processed($locale, $source, $status, $package);
114			}
115			}
116			}
117
118			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
122			return $this->processor($source)
123			->force($this->hasForce() \|\| $this->hasProcessed($target))
124			->whenPackage($package)
125			->whenLocale($locale)
126			->whenSourceFilename($source, $this->hasInline())
127			->whenTargetFilename($target ?: $source)
128			->run();
129			}
130
131			protected function locales(): array
132			{
133			$this->log('Getting a list of localizations...');
134
135			if (! empty($this->locales)) {
136			return $this->locales;
137			}
138
139			return $this->locales = LocalesSupport::make($this->input, $this->output, $this->action(), $this->targetLocales())->get();
140			}
141
142			protected function targetLocales(): array
143			{
144			$this->log('Getting a list of installed localizations...');
145
146			return Locales::installed();
147			}
148
149			protected function packages(): array
150			{
151			$this->log('Getting a list of packages available for processing...');
152
153			return Packages::get();
154			}
155
156			protected function files(string $package): array
157			{
158			$this->log('Getting a list of files for the ', $package, 'package...');
159
160			if ($this->files[$package] ?? false) {
161			return $this->files[$package];
162			}
163
164			$path = $this->pathSource($package, LocalesList::ENGLISH);
165
166			return $this->files[$package] = File::names($path, static function ($filename) {
167			return ! Str::contains($filename, 'inline');
168			});
169			}
170
171			/**
172			* @return array\|\Helldar\LaravelLangPublisher\Plugins\Plugin[]
173			*/
174			protected function plugins(): array
175			{
176			if (! empty($this->plugins)) {
177			return $this->plugins;
178			}
179
180			$plugins = array_map(static function ($plugin) {
181			/* @var \Helldar\LaravelLangPublisher\Plugins\Plugin $plugin */
182			return $plugin::make();
183			}, $this->getPlugins());
184
185			$plugins = array_filter($plugins, static function (Plugin $plugin) {
186			return $plugin->has();
187			});
188
189			return $this->plugins = $plugins;
190			}
191
192			protected function start(): void
193			{
194			$this->log('Running the console command:', parent::class);
195
196			$action = $this->action()->present(true);
197
198			$this->info($action . ' localizations...');
199			}
200
201			protected function end(): void
202			{
203			$this->log('Completing the execution of the console command...');
204
205			$action = $this->action()->past();
206
207			$this->info('Localizations have ben successfully ' . $action . '.');
208			}
209
210			protected function processing(string $locale, string $filename, string $package = null): void
211			{
212			$this->log('Displaying a message about the start of file processing: locale is', $locale, ', filename is', $filename, ', package is', $package . '...');
213
214			$message = $this->message($locale, $filename, $package)->start();
215
216			$this->output->write($message);
217			}
218
219			protected function processed(string $locale, string $filename, string $status, string $package = null): void
220			{
221			$this->log('Displaying a message about the finish of file processing: locale is', $locale, ', filename is', $filename, ', package is', $package . '...');
222
223			$message = $this->message($locale, $filename, $package)->finish($status);
224
225			$this->output->writeln($message);
226			}
227
228			protected function message(string $locale, string $filename, string $package = null): InfoSupport
229			{
230			$this->log('Preparing an object for displaying a message: locale is', $locale, ', filename is', $filename, ', package is', $package . '...');
231
232			return Info::same()
233			->package($package)
234			->locale($locale, $this->localesLength())
235			->filename($filename, $this->filesLength());
236			}
237
238			protected function localesLength(): int
239			{
240			$this->log('Getting the maximum length of a localization string...');
241
242			if ($this->locales_length > 0) {
243			return $this->locales_length;
244			}
245
246			$this->log('Calculating the maximum length of a localization string...');
247
248			return $this->locales_length = Arr::longestStringLength($this->locales());
249			}
250
251			protected function filesLength(): int
252			{
253			$this->log('Getting the maximum length of a filenames...');
254
255			if ($this->files_length > 0) {
256			return $this->files_length;
257			}
258
259			$this->log('Calculating the maximum length of a filenames...');
260
261			$files = [];
262
263			foreach ($this->packages() as $package) {
264			$files = array_merge($files, $this->files($package));
265			}
266
267			return $this->files_length = Arr::longestStringLength(array_unique($files));
268			}
269
270			protected function hasInline(): bool
271			{
272			$this->log('Getting a use case for a validation file.');
273
274			return Config::hasInline();
275			}
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

Push — features/split-packages ( 745907...9ff8f9 )

BaseCommand::ranPackages() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like