Config::substituteOutputDirs() - Code Metrics - Inspection of "Remove redundant" - yiisoft/composer-config-plugin - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#30)

by Dmitriy

created 2020-04-18 12:51 UTC

Config::substituteOutputDirs() A

↳ Parent: Config

Complexity

Conditions	1
Paths	1

Size

Total Lines	5
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	2
dl	0
loc	5
c	0
b	0
f	0
rs	10
cc	1
nc	1
nop	1

<?php

namespace Yiisoft\Composer\Config\Config;

use Yiisoft\Composer\Config\Builder;
use Yiisoft\Composer\Config\ContentWriter;
use Yiisoft\Composer\Config\Reader\ReaderFactory;
use Yiisoft\Composer\Config\Util\ConfigMergeHelper;
use Yiisoft\Composer\Config\Util\Helper;

/**
 * Config class represents output configuration file.
 */
class Config
{
    private const BASE_DIR_MARKER = '<<<base-dir>>>';

    /**
     * @var string config name
     */
    private string $name;

    /**
     * @var array sources - paths to config source files
     */
    private array $sources = [];

    /**
     * @var array config value
     */
    protected array $values = [];

    protected Builder $builder;

    protected ContentWriter $contentWriter;

    public function __construct(Builder $builder, string $name)
    {
        $this->builder = $builder;
        $this->name = $name;
        $this->contentWriter = new ContentWriter();
    }

    public function clone(Builder $builder): self
    {
        $config = new Config($builder, $this->name);
        $config->sources = $this->sources;
        $config->values = $this->values;

        return $config;
    }

    public function getValues(): array
    {
        return $this->values;
    }

    public function load(array $paths = []): self
    {
        $this->sources = $this->loadFiles($paths);

        return $this;
    }

    private function loadFiles(array $paths): array
    {
        switch (count($paths)) {
            case 0:
                return [];
            case 1:
                return [$this->loadFile(reset($paths))];
        }

        $configs = [];
        foreach ($paths as $path) {
            $cs = $this->loadFiles($this->glob($path));
            foreach ($cs as $config) {
                if (!empty($config)) {
                    $configs[] = $config;
                }
            }
        }

        return $configs;
    }

    private function glob(string $path): array
    {
        if (strpos($path, '*') === false) {
            return [$path];
        }

        return glob($path);

    }

    /**
     * Reads config file.
     *
     * @param string $path
     * @return array configuration read from file
     */
    protected function loadFile($path): array
    {
        $reader = ReaderFactory::get($this->builder, $path);

        return $reader->read($path);
    }

    /**
     * Merges given configs and writes at given name.
     *
     * @return Config
     */
    public function build(): self
    {
        $this->values = $this->calcValues($this->sources);

        return $this;
    }

    public function write(): self
    {
        $this->writeFile($this->getOutputPath(), $this->values);

        return $this;
    }

    protected function calcValues(array $sources): array
    {
        $values = call_user_func_array([ConfigMergeHelper::class, 'mergeConfig'], $sources);

        return $this->substituteOutputDirs($values);
    }

    protected function writeFile(string $path, array $data): void
    {
        $depth = $this->findDepth();
        $baseDir = $depth > 0 ? "dirname(__DIR__, $depth)" : '__DIR__';

        $params = $this->paramsRequired() ? "(array) require __DIR__ . '/params.php'" : '[]';
        $constants = $this->constantsRequired() ? $this->builder->getConfig('constants')->buildRequires() : '';
        $envs = $this->envsRequired() ? "\$_ENV = array_merge((array) require __DIR__ . '/envs.php', \$_ENV);" : '';
        $variables = Helper::exportVar($data);

        $content = <<<PHP
<?php
\$baseDir = {$baseDir};
\$params = {$params};
{$constants}
{$envs}
return {$variables};
PHP;

        $this->contentWriter->write($path, $this->replaceMarkers($content) . "\n");
    }

    public function envsRequired(): bool
    {
        return true;
    }

    public function constantsRequired(): bool
    {
        return true;
    }

    public function paramsRequired(): bool
    {
        return true;
    }

    private function findDepth(): int
    {
        $outDir = realpath(dirname($this->normalizePath($this->getOutputPath())));
        $diff = substr($outDir, strlen(realpath($this->getBaseDir())));

        return substr_count($diff, '/');
    }

    private function replaceMarkers(string $content): string
    {
        return str_replace(
            ["'" . self::BASE_DIR_MARKER, "'?" . self::BASE_DIR_MARKER],
            ["\$baseDir . '", "'?' . \$baseDir . '"],
            $content
        );
    }

    /**
     * Substitute output paths in given data array recursively with marker.
     *
     * @param array $data
     * @return array
     */
    protected function substituteOutputDirs(array $data): array
    {
        $dir = $this->normalizePath($this->getBaseDir());

        return $this->substitutePaths($data, $dir, self::BASE_DIR_MARKER);
    }

    /**
     * Normalizes given path with given directory separator.
     * Default forced to Unix directory separator for substitutePaths to work properly in Windows.
     *
     * @param string $path path to be normalized
     * @param string $ds directory separator
     * @return string
     */
    private function normalizePath($path): string
    {
        return rtrim(strtr($path, '/\\', '//'), '/');
    }

    /**
     * Substitute all paths in given array recursively with alias if applicable.
     *
     * @param array $data
     * @param string $dir
     * @param string $alias
     * @return array
     */
    private function substitutePaths($data, $dir, $alias): array
    {
        foreach ($data as &$value) {
            if (is_string($value)) {
                $value = $this->substitutePath($value, $dir, $alias);
            } elseif (is_array($value)) {
                $value = $this->substitutePaths($value, $dir, $alias);
            }
        }

        return $data;
    }

    /**
     * Substitute path with alias if applicable.
     *
     * @param string $path
     * @param string $dir
     * @param string $alias
     * @return string
     */
    private function substitutePath($path, $dir, $alias): string
    {
        $end = $dir . '/';
        $skippable = 0 === strncmp($path, '?', 1);
        if ($skippable) {
            $path = substr($path, 1);
        }
        if ($path === $dir) {
            $result = $alias;
        } elseif (strpos($path, $end) === 0) {
            $result = $alias . substr($path, strlen($end) - 1);
        } else {
            $result = $path;
        }

        return ($skippable ? '?' : '') . $result;
    }

    private function getBaseDir(): string
    {
        return $this->builder->getBaseDir();
    }

    protected function getOutputPath(string $name = null): string
    {
        return $this->builder->getOutputPath($name ?: $this->name);
    }
}


1			<?php
2
3			namespace Yiisoft\Composer\Config\Config;
4
5			use Yiisoft\Composer\Config\Builder;
6			use Yiisoft\Composer\Config\ContentWriter;
7			use Yiisoft\Composer\Config\Reader\ReaderFactory;
8			use Yiisoft\Composer\Config\Util\ConfigMergeHelper;
9			use Yiisoft\Composer\Config\Util\Helper;
10
11			/**
12			* Config class represents output configuration file.
13			*/
14			class Config
15			{
16			private const BASE_DIR_MARKER = '<<<base-dir>>>';
17
18			/**
19			* @var string config name
20			*/
21			private string $name;
22
23			/**
24			* @var array sources - paths to config source files
25			*/
26			private array $sources = [];
27
28			/**
29			* @var array config value
30			*/
31			protected array $values = [];
32
33			protected Builder $builder;
34
35			protected ContentWriter $contentWriter;
36
37			public function __construct(Builder $builder, string $name)
38			{
39			$this->builder = $builder;
40			$this->name = $name;
41			$this->contentWriter = new ContentWriter();
42			}
43
44			public function clone(Builder $builder): self
45			{
46			$config = new Config($builder, $this->name);
47			$config->sources = $this->sources;
48			$config->values = $this->values;
49
50			return $config;
51			}
52
53			public function getValues(): array
54			{
55			return $this->values;
56			}
57
58			public function load(array $paths = []): self
59			{
60			$this->sources = $this->loadFiles($paths);
61
62			return $this;
63			}
64
65			private function loadFiles(array $paths): array
66			{
67			switch (count($paths)) {
68			case 0:
69			return [];
70			case 1:
71			return [$this->loadFile(reset($paths))];
72			}
73
74			$configs = [];
75			foreach ($paths as $path) {
76			$cs = $this->loadFiles($this->glob($path));
77			foreach ($cs as $config) {
78			if (!empty($config)) {
79			$configs[] = $config;
80			}
81			}
82			}
83
84			return $configs;
85			}
86
87			private function glob(string $path): array
88			{
89			if (strpos($path, '*') === false) {
90			return [$path];
91			}
92
93			return glob($path);
			0 ignored issues – show Bug Best Practice introduced 2020-03-22 10:14 UTC by Report Bug Copy Issue Report The expression `return glob($path)` could return the type `false` which is incompatible with the type-hinted return `array`. Consider adding an additional type-check to rule them out. Loading history...
94			}
95
96			/**
97			* Reads config file.
98			*
99			* @param string $path
100			* @return array configuration read from file
101			*/
102			protected function loadFile($path): array
103			{
104			$reader = ReaderFactory::get($this->builder, $path);
105
106			return $reader->read($path);
107			}
108
109			/**
110			* Merges given configs and writes at given name.
111			*
112			* @return Config
113			*/
114			public function build(): self
115			{
116			$this->values = $this->calcValues($this->sources);
117
118			return $this;
119			}
120
121			public function write(): self
122			{
123			$this->writeFile($this->getOutputPath(), $this->values);
124
125			return $this;
126			}
127
128			protected function calcValues(array $sources): array
129			{
130			$values = call_user_func_array([ConfigMergeHelper::class, 'mergeConfig'], $sources);
131
132			return $this->substituteOutputDirs($values);
133			}
134
135			protected function writeFile(string $path, array $data): void
136			{
137			$depth = $this->findDepth();
138			$baseDir = $depth > 0 ? "dirname(__DIR__, $depth)" : '__DIR__';
139
140			$params = $this->paramsRequired() ? "(array) require __DIR__ . '/params.php'" : '[]';
141			$constants = $this->constantsRequired() ? $this->builder->getConfig('constants')->buildRequires() : '';
142			$envs = $this->envsRequired() ? "\$_ENV = array_merge((array) require __DIR__ . '/envs.php', \$_ENV);" : '';
143			$variables = Helper::exportVar($data);
144
145			$content = <<<PHP
146			<?php
147			\$baseDir = {$baseDir};
148			\$params = {$params};
149			{$constants}
150			{$envs}
151			return {$variables};
152			PHP;
153
154			$this->contentWriter->write($path, $this->replaceMarkers($content) . "\n");
155			}
156
157			public function envsRequired(): bool
158			{
159			return true;
160			}
161
162			public function constantsRequired(): bool
163			{
164			return true;
165			}
166
167			public function paramsRequired(): bool
168			{
169			return true;
170			}
171
172			private function findDepth(): int
173			{
174			$outDir = realpath(dirname($this->normalizePath($this->getOutputPath())));
175			$diff = substr($outDir, strlen(realpath($this->getBaseDir())));
176
177			return substr_count($diff, '/');
178			}
179
180			private function replaceMarkers(string $content): string
181			{
182			return str_replace(
183			["'" . self::BASE_DIR_MARKER, "'?" . self::BASE_DIR_MARKER],
184			["\$baseDir . '", "'?' . \$baseDir . '"],
185			$content
186			);
187			}
188
189			/**
190			* Substitute output paths in given data array recursively with marker.
191			*
192			* @param array $data
193			* @return array
194			*/
195			protected function substituteOutputDirs(array $data): array
196			{
197			$dir = $this->normalizePath($this->getBaseDir());
198
199			return $this->substitutePaths($data, $dir, self::BASE_DIR_MARKER);
200			}
201
202			/**
203			* Normalizes given path with given directory separator.
204			* Default forced to Unix directory separator for substitutePaths to work properly in Windows.
205			*
206			* @param string $path path to be normalized
207			* @param string $ds directory separator
208			* @return string
209			*/
210			private function normalizePath($path): string
211			{
212			return rtrim(strtr($path, '/\\', '//'), '/');
213			}
214
215			/**
216			* Substitute all paths in given array recursively with alias if applicable.
217			*
218			* @param array $data
219			* @param string $dir
220			* @param string $alias
221			* @return array
222			*/
223			private function substitutePaths($data, $dir, $alias): array
224			{
225			foreach ($data as &$value) {
226			if (is_string($value)) {
227			$value = $this->substitutePath($value, $dir, $alias);
228			} elseif (is_array($value)) {
229			$value = $this->substitutePaths($value, $dir, $alias);
230			}
231			}
232
233			return $data;
234			}
235
236			/**
237			* Substitute path with alias if applicable.
238			*
239			* @param string $path
240			* @param string $dir
241			* @param string $alias
242			* @return string
243			*/
244			private function substitutePath($path, $dir, $alias): string
245			{
246			$end = $dir . '/';
247			$skippable = 0 === strncmp($path, '?', 1);
248			if ($skippable) {
249			$path = substr($path, 1);
250			}
251			if ($path === $dir) {
252			$result = $alias;
253			} elseif (strpos($path, $end) === 0) {
254			$result = $alias . substr($path, strlen($end) - 1);
255			} else {
256			$result = $path;
257			}
258
259			return ($skippable ? '?' : '') . $result;
260			}
261
262			private function getBaseDir(): string
263			{
264			return $this->builder->getBaseDir();
265			}
266
267			protected function getOutputPath(string $name = null): string
268			{
269			return $this->builder->getOutputPath($name ?: $this->name);
270			}
271			}
272

yiisoft / composer-config-plugin

Pull Request — master (#30)

Config::substituteOutputDirs() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like