BaseCommand::validatePackage() - Code Metrics - Inspection of "Adding support for split files" - andrey-helldar/laravel-lang-publisher - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — 9.x (#103)

by Andrey

created 2021-05-18 10:42 UTC

BaseCommand::validatePackage() A

↳ Parent: BaseCommand

Complexity

Conditions	1
Paths	1

Size

Total Lines	5
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	2
nc	1
nop	1
dl	0
loc	5
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\Constants\Packages as PackagesConst;
use Helldar\LaravelLangPublisher\Contracts\Actionable;
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\Directory;
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 $extra_packages;

    protected $processed = [];

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

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

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

        foreach ($this->packages() as $package) {
            $this->log('Packages 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->ranPackages($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, $filename);

            $this->pushProcessed($filename);

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

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

        foreach ($this->extraPackages() as $extra_package) {
            if (! $extra_package->has($package, $locale)) {
                continue;
            }

            $name      = $extra_package->vendor();
            $filenames = $extra_package->source();

            foreach ($filenames as $filename) {
                $path   = $extra_package->targetPath($locale, $filename);
                $target = $extra_package->targetFilename($locale, $filename);

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

                $this->ensureDirectory($path, true);

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

                $this->pushProcessed($path);

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

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

        return $this->processor($source_filename)
            ->force($this->hasForce() || $this->hasProcessed($source_filename))
            ->whenPackage($package)
            ->whenLocale($locale)
            ->whenSourceFilename($source_filename, $this->hasInline())
            ->whenTargetFilename($target_filename)
            ->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\Packages\Package[]
     */
    protected function extraPackages(): array
    {
        if (! empty($this->extra_packages)) {
            return $this->extra_packages;
        }

        return $this->extra_packages = array_map(static function ($package) {
            /* @var \Helldar\LaravelLangPublisher\Packages\Package $package */
            return $package::make();
        }, PackagesConst::ALL);
    }

    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 action(): Actionable
    {
        $this->log('Getting the action...');

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

    protected function ensureDirectory(string $path, bool $is_file = false): void
    {
        $path = $is_file ? $this->pathDirectory($path) : $path;

        Directory::ensureDirectory($path);
    }

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

andrey-helldar / laravel-lang-publisher

Pull Request — 9.x (#103)

BaseCommand::validatePackage() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like