Environment::getMinifier() - Code Metrics - Enjoyzz/assets-collector - Measure and Improve Code Quality continuously with Scrutinizer

Environment::getMinifier() A
last analyzed 2025-04-06 17:03 UTC

↳ Parent: Environment

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	1
CRAP Score	1

Importance

Changes

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

<?php

declare(strict_types=1);

namespace Enjoys\AssetsCollector;

use Closure;
use Enjoys\AssetsCollector\Exception\PathDirectoryIsNotValid;
use Enjoys\AssetsCollector\Strategy\ManyFilesStrategy;
use Psr\Http\Client\ClientInterface;
use Psr\Http\Message\RequestFactoryInterface;
use Psr\Log\LoggerInterface;
use Psr\Log\NullLogger;

use function putenv;

class Environment
{

    private string $projectDir;

    private string $compileDir;

    private string $baseUrl = '';

    private int $cacheTime = -1;

    private ?string $version = null;

    private string $paramVersion = 'v';

    /**
     * @var class-string<Strategy>|Strategy

     */
    private string|Strategy $strategy = ManyFilesStrategy::class;

    /**
     * @var array<string, Closure(string):string|Minifier|null>

     */
    private array $minifiers = [];

    /**
     * @var array<string, Closure(Asset[]):string|Renderer|null>

     */
    private array $renderers = [];

    private ?ClientInterface $httpClient = null;

    private ?RequestFactoryInterface $requestFactory = null;

    /**
     * Environment constructor.
     * @param string $compileDir
     * @param string $projectDir Если пустая строка, то realpath вернет текущую рабочую директорию
     * @param LoggerInterface $logger
     */
    public function __construct(
        string $compileDir = '/',
        string $projectDir = '',
        private LoggerInterface $logger = new NullLogger()
    ) {
        $projectDir = realpath($projectDir);

        if ($projectDir === false) {
            throw new PathDirectoryIsNotValid(
                "The project directory is not installed or the directory could not be determined automatically"
            );
        }
        putenv("ASSETS_PROJECT_DIRECTORY=$projectDir/");

        $this->projectDir = $projectDir;
        $this->compileDir = $this->normalizeCompileDir($compileDir);
    }

    public function getProjectDir(): string
    {
        return $this->projectDir;
    }

    /**
     * Функцию realpath() нельзя применять так как директории изначально может не быть,
     * она может потом быть создана, если будут права
     * @infection-ignore-all
     */
    private function normalizeCompileDir(string $path): string
    {
        if (str_starts_with($path, $this->getProjectDir())) {
            $path = str_replace($this->getProjectDir(), '', $path);
        }
        $path = $this->getProjectDir() . '/' . ltrim($path, '/\.');
        return rtrim($path, '/');
    }

    public function getCompileDir(): string
    {
        return $this->compileDir;
    }

    public function setBaseUrl(string $baseUrl = '/'): Environment
    {
        $this->baseUrl = rtrim($baseUrl, '\/');
        return $this;
    }

    public function getBaseUrl(): string
    {
        return $this->baseUrl;
    }

    public function setCacheTime(int $cacheTime): Environment
    {
        $this->cacheTime = $cacheTime;
        return $this;
    }

    public function getCacheTime(): int
    {
        return $this->cacheTime;
    }

    public function getStrategy(): Strategy
    {
        if ($this->strategy instanceof Strategy) {
            return $this->strategy;
        }
        return new $this->strategy();
    }

    /**
     * @param class-string<Strategy>|Strategy $strategy

     */
    public function setStrategy(string|Strategy $strategy): Environment
    {
        $this->strategy = $strategy;
        return $this;
    }

    public function getLogger(): LoggerInterface
    {
        return $this->logger;
    }

    public function setLogger(LoggerInterface $logger): Environment
    {
        $this->logger = $logger;
        return $this;
    }

    public function getHttpClient(): ?ClientInterface
    {
        return $this->httpClient;
    }

    public function setHttpClient(?ClientInterface $httpClient): Environment
    {
        $this->httpClient = $httpClient;
        return $this;
    }

    public function getRequestFactory(): ?RequestFactoryInterface
    {
        return $this->requestFactory;
    }

    public function setRequestFactory(?RequestFactoryInterface $requestFactory): Environment
    {
        $this->requestFactory = $requestFactory;
        return $this;
    }

    /**
     * @param AssetType $type
     * @param Minifier|Closure(string):string|null $minifier
     * @return Environment
     */
    public function setMinifier(AssetType $type, Minifier|Closure|null $minifier): Environment
    {
        $this->minifiers[$type->value] = $minifier;
        return $this;
    }

    public function getMinifier(AssetType $type): ?Minifier
    {
        return MinifierFactory::get($this->minifiers[$type->value] ?? null);
    }

    /**
     * @param AssetType $type
     * @param Renderer|Closure(Asset[]):string|null $renderer
     * @return Environment
     */
    public function setRenderer(AssetType $type, Renderer|Closure|null $renderer): Environment
    {
        $this->renderers[$type->value] = $renderer;
        return $this;
    }

    public function getRenderer(AssetType $type): Renderer
    {
        $renderer = $this->renderers[$type->value]
            ?? RenderFactory::getDefaultRenderer($type);

        if ($renderer instanceof Renderer) {
            return $renderer;
        }
        return RenderFactory::createFromClosure($renderer);
    }

    public function setParamVersion(string $paramVersion): Environment
    {
        $this->paramVersion = $paramVersion;
        return $this;
    }

    public function setVersion(string|int|float $version): Environment
    {
        $this->version = (string)$version;
        return $this;
    }

    /**
     * @return array<string, string>
     */
    public function getVersionQuery(): array
    {
        if ($this->version === null) {
            return [];
        }
        return [$this->paramVersion => $this->version];
    }

    public function getVersion(): ?string
    {
        return $this->version;
    }

    public function getParamVersion(): string
    {
        return $this->paramVersion;
    }

}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace Enjoys\AssetsCollector;
6
7		use Closure;
8		use Enjoys\AssetsCollector\Exception\PathDirectoryIsNotValid;
9		use Enjoys\AssetsCollector\Strategy\ManyFilesStrategy;
10		use Psr\Http\Client\ClientInterface;
11		use Psr\Http\Message\RequestFactoryInterface;
12		use Psr\Log\LoggerInterface;
13		use Psr\Log\NullLogger;
14
15		use function putenv;
16
17		class Environment
18		{
19
20		private string $projectDir;
21
22		private string $compileDir;
23
24		private string $baseUrl = '';
25
26		private int $cacheTime = -1;
27
28		private ?string $version = null;
29
30		private string $paramVersion = 'v';
31
32		/**
33		* @var class-string<Strategy>\|Strategy
		0 ignored issues – show Documentation Bug introduced 2025-04-06 17:03 UTC by Report Bug Copy Issue Report The doc comment `class-string<Strategy>\|Strategy` at position `0` could not be parsed: Unknown type name 'class-string' at position 0 in class-string<Strategy>\|Strategy. Loading history...
34		*/
35		private string\|Strategy $strategy = ManyFilesStrategy::class;
36
37		/**
38		* @var array<string, Closure(string):string\|Minifier\|null>
		0 ignored issues – show Documentation Bug introduced 2025-04-06 17:03 UTC by Report Bug Copy Issue Report The doc comment `array<string, Closure(st...):string\|Minifier\|null>` at position `4` could not be parsed: Expected '>' at position 4, but found 'Closure'. Loading history...
39	80	*/
40		private array $minifiers = [];
41	80
42	80	/**
43	80	* @var array<string, Closure(Asset[]):string\|Renderer\|null>
		0 ignored issues – show Documentation Bug introduced 2025-04-06 17:03 UTC by Report Bug Copy Issue Report The doc comment `array<string, Closure(As...):string\|Renderer\|null>` at position `4` could not be parsed: Expected '>' at position 4, but found 'Closure'. Loading history...
44	80	*/
45		private array $renderers = [];
46	80
47		private ?ClientInterface $httpClient = null;
48	80
49	1	private ?RequestFactoryInterface $requestFactory = null;
50	1
51	1	/**
52		* Environment constructor.
53	79	* @param string $compileDir
54	79	* @param string $projectDir Если пустая строка, то realpath вернет текущую рабочую директорию
55		* @param LoggerInterface $logger
56	79	*/
57	79	public function __construct(
58		string $compileDir = '/',
59		string $projectDir = '',
60		private LoggerInterface $logger = new NullLogger()
61		) {
62		$projectDir = realpath($projectDir);
63	79
64		if ($projectDir === false) {
65	79	throw new PathDirectoryIsNotValid(
66		"The project directory is not installed or the directory could not be determined automatically"
67		);
68		}
69		putenv("ASSETS_PROJECT_DIRECTORY=$projectDir/");
70
71		$this->projectDir = $projectDir;
72		$this->compileDir = $this->normalizeCompileDir($compileDir);
73		}
74
75	79	public function getProjectDir(): string
76		{
77	79	return $this->projectDir;
78	26	}
79
80	79	/**
81	79	* Функцию realpath() нельзя применять так как директории изначально может не быть,
82		* она может потом быть создана, если будут права
83		* @infection-ignore-all
84		*/
85		private function normalizeCompileDir(string $path): string
86		{
87	42	if (str_starts_with($path, $this->getProjectDir())) {
88		$path = str_replace($this->getProjectDir(), '', $path);
89	42	}
90		$path = $this->getProjectDir() . '/' . ltrim($path, '/\.');
91		return rtrim($path, '/');
92		}
93
94		public function getCompileDir(): string
95		{
96		return $this->compileDir;
97	42	}
98
99	42	public function setBaseUrl(string $baseUrl = '/'): Environment
100	42	{
101		$this->baseUrl = rtrim($baseUrl, '\/');
102		return $this;
103		}
104
105		public function getBaseUrl(): string
106	21	{
107		return $this->baseUrl;
108	21	}
109
110		public function setCacheTime(int $cacheTime): Environment
111		{
112		$this->cacheTime = $cacheTime;
113		return $this;
114		}
115	1
116		public function getCacheTime(): int
117	1	{
118	1	return $this->cacheTime;
119		}
120
121		public function getStrategy(): Strategy
122		{
123		if ($this->strategy instanceof Strategy) {
124	15	return $this->strategy;
125		}
126	15	return new $this->strategy();
127	15	}
128
129	1	/**
130		* @param class-string<Strategy>\|Strategy $strategy
		0 ignored issues – show Documentation Bug introduced 2025-04-06 17:03 UTC by Report Bug Copy Issue Report The doc comment `class-string<Strategy>\|Strategy` at position `0` could not be parsed: Unknown type name 'class-string' at position 0 in class-string<Strategy>\|Strategy. Loading history...
131		*/
132		public function setStrategy(string\|Strategy $strategy): Environment
133		{
134		$this->strategy = $strategy;
135		return $this;
136	1	}
137
138	1	public function getLogger(): LoggerInterface
139	1	{
140		return $this->logger;
141		}
142
143		public function setLogger(LoggerInterface $logger): Environment
144		{
145		$this->logger = $logger;
146		return $this;
147	2	}
148
149	2	public function getHttpClient(): ?ClientInterface
150	2	{
151		return $this->httpClient;
152		}
153
154		public function setHttpClient(?ClientInterface $httpClient): Environment
155		{
156	7	$this->httpClient = $httpClient;
157		return $this;
158	7	}
159
160		public function getRequestFactory(): ?RequestFactoryInterface
161	13	{
162		return $this->requestFactory;
163	13	}
164
165		public function setRequestFactory(?RequestFactoryInterface $requestFactory): Environment
166	1	{
167		$this->requestFactory = $requestFactory;
168	1	return $this;
169		}
170
171		/**
172		* @param AssetType $type
173		* @param Minifier\|Closure(string):string\|null $minifier
174		* @return Environment
175	16	*/
176		public function setMinifier(AssetType $type, Minifier\|Closure\|null $minifier): Environment
177	16	{
178	16	$this->minifiers[$type->value] = $minifier;
179		return $this;
180		}
181	39
182		public function getMinifier(AssetType $type): ?Minifier
183	39	{
184		return MinifierFactory::get($this->minifiers[$type->value] ?? null);
185		}
186	5
187		/**
188	5	* @param AssetType $type
189	5	* @param Renderer\|Closure(Asset[]):string\|null $renderer
190		* @return Environment
191		*/
192	10	public function setRenderer(AssetType $type, Renderer\|Closure\|null $renderer): Environment
193		{
194	10	$this->renderers[$type->value] = $renderer;
195		return $this;
196		}
197	14
198		public function getRenderer(AssetType $type): Renderer
199	14	{
200		$renderer = $this->renderers[$type->value]
201		?? RenderFactory::getDefaultRenderer($type);
202
203		if ($renderer instanceof Renderer) {
204		return $renderer;
205		}
206	6	return RenderFactory::createFromClosure($renderer);
207		}
208	6
209	1	public function setParamVersion(string $paramVersion): Environment
210		{
211	5	$this->paramVersion = $paramVersion;
212		return $this;
213		}
214
215		public function setVersion(string\|int\|float $version): Environment
216		{
217	4	$this->version = (string)$version;
218		return $this;
219	4	}
220
221		/**
222		* @return array<string, string>
223		*/
224		public function getVersionQuery(): array
225		{
226		if ($this->version === null) {
227		return [];
228		}
229		return [$this->paramVersion => $this->version];
230		}
231	4
232		public function getVersion(): ?string
233	4	{
234		return $this->version;
235		}
236	2
237		public function getParamVersion(): string
238	2	{
239	2	return $this->paramVersion;
240		}
241
242		}
243

Enjoyzz / assets-collector

Environment::getMinifier() A last analyzed 2025-04-06 17:03 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

Environment::getMinifier() A
last analyzed 2025-04-06 17:03 UTC