GLConf::stringPlaceholderHandler() - Code Metrics - Inspection of "Moving to Scrutinizer - fixing for complexity." - ellisgl/GeekLab-Conf - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Branch — master (29d251)

by Kenneth

created 2019-06-19 00:16 UTC

GLConf::stringPlaceholderHandler() A

↳ Parent: GLConf

Complexity

Conditions	4
Paths	1

Size

Total Lines	14
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	6
dl	0
loc	14
rs	10
c	0
b	0
f	0
cc	4
nc	1
nop	1

<?php

namespace GeekLab\Conf;

use GeekLab\Conf\Driver\ConfDriverInterface;

final class GLConf
{
    /** @var ConfDriverInterface $driver */
    private $driver;

    /** @var array $configuration The compiled configuration. */
    protected $configuration = [];

    /**
     * GLConf constructor.
     * Inject our driver (strategy) here.
     *
     * @param ConfDriverInterface $driver
     */
    public function __construct(ConfDriverInterface $driver)
    {
        $this->driver = $driver;
    }

    /**
     * Return the compiled configuration.
     *
     * @return array
     */
    public function getAll(): array
    {
        return $this->configuration;
    }

    /**
     * Get data by dot notation.
     * Stolen from: https://stackoverflow.com/a/14706302/344028
     *
     * @param string $key dot notated array key accessor.
     *
     * @return mixed
     */
    public function get(string $key)
    {
        /** @var string $key Convert key to upper case. */
        $key = strtoupper($key);

        /** @var mixed $config Save configuration for local scope modification. */
        $config = $this->configuration;

        /** @var bool|array $token Tokenize the key to do iterations over the config with. */
        $token = strtok($key, '.');

        // Loop until we are out of tokens.
        while ($token !== false) {
            if (!isset($config[$token])) {
                // Array key of $token wasn't found.
                return false;
            }

            // Save the data found.
            $config = $config[$token];

            // Advanced to the next token, or set token to false if nothing else if left..
            $token  = strtok('.');
        }

        // Return the valid found by the previous loop.
        return $config;
    }

    /**
     * Make the array conform to some sort of standard.
     * -  Convert key names to uppercase.
     * -  Convert spaces and periods to underscores.
     *
     * @param array $arr
     *
     * @return array
     */
    protected function conformArray(array $arr): array
    {
        // Store our conformed array for returning.
        $fixed = [];

        // Convert keys to uppercase.
        $arr = array_change_key_case($arr, CASE_UPPER);

        foreach ($arr as $k => $v) {
            // Recursively conform the inner arrays.
            if (is_array($v)) {
                $v = $this->conformArray($v);
            }

            // Replace spaces and periods with underscores.
            $fixed[preg_replace('/\s+|\.+/', '_', $k)] = $v;
        }

        // Return the conformed array.
        return $fixed;
    }

    /**
     * @param array $data
     * @return array
     */
    private function arrayPlaceholderHandler(array $data): array
    {
        // It's an array, so let's loop through it.
        foreach ($data as $k => $val) {
            if (!is_array($val)) {
                // Find the self referenced placeholders and fill them.
                $data[$k] = preg_replace_callback('/@\[([a-zA-Z0-9_.-]*?)]/', function ($matches) {
                    // Does this key exist, is so fill this match, if not, just return the match intact.
                    return $this->get($matches[1]) ?: $matches[0];
                }, $val);

                // Find the recursive self referenced placeholders and fill them.
                if ($data[$k] !== $val && preg_match('/@\[([a-zA-Z0-9_.-]*?)]/', $data[$k])) {
                    $data[$k] = $this->replacePlaceholders($data[$k]);
                }

                // Find the environment variable placeholders and fill them.
                $data[$k] = preg_replace_callback('/\$\[([a-zA-Z0-9_.-]*?)]/', static function ($matches) {
                    // If locally set environment variable (variable not set by a SAPI) found, replace with it's value.
                    if (!empty(getenv($matches[1], true))) {
                        // Try local only environment variables first (variable not set by a SAPI)
                        $ret = getenv($matches[1], true);
                    } else {
                        // Don't replace.
                        $ret = $matches[0];
                    }

                    return $ret;
                }, $data[$k]);
            } else {
                // Recursively replace placeholders.
                $data[$k] = $this->replacePlaceholders($val);
            }
        }

        return $data;
    }

    /**
     * @param $data
     * @return array
     */
    private function stringPlaceholderHandler(string $data): string
    {
        // Find the self referenced placeholders and fill them.
        return preg_replace_callback('/@\[([a-zA-Z0-9_.-]*?)]/', function ($matches) {

            // Does this key exist, is so fill this match, if not, just return the match intact.
            $ret = $this->get($matches[1]) ?: $matches[0];

            // Looks like we have a recursive self referenced placeholder.
            if ($ret !== $matches[0] && preg_match('/@\[(.*?)]/', $matches[0])) {
                $ret = $this->replacePlaceholders($ret);
            }

            return $ret;
        }, $data);
    }
    /**
     * Self referenced and environment variable placeholder replacement.
     *
     * @param  mixed $data
     * @return mixed
     */
    protected function replacePlaceholders($data)
    {
        if (is_array($data)) {
            $data = $this->arrayPlaceholderHandler($data);
        } elseif (is_string($data)) {
            // It's a string!
            // Certain recursive stuff, like @[SelfReferencedPlaceholder.@[SomeStuff.a]] is what triggers this part.
            $data = $this->stringPlaceholderHandler($data);
        }

        return $data;
    }


    /**
     * Initialize the configuration system.
     */
    public function init(): void
    {
        // Load main (top level) configuration and conform it (uppercase and changes spaces to underscores in keys).
        $this->configuration = $this->driver->parseConfigurationFile();
        $this->configuration = $this->conformArray($this->configuration);
        $config = [];

        // Load in the extra configuration via the CONF property.
        if (isset($this->configuration['CONF']) && is_array($this->configuration['CONF'])) {
            foreach ($this->configuration['CONF'] as $file) {
                // Load in the referenced configuration from the main configuration.
                $innerConfig = $this->driver->parseConfigurationFile($file);

                // Conform the configuration array.
                $innerConfig = $this->conformArray($innerConfig);

                // Strip out anything that wasn't in a section (non-array value at the top level).
                // We don't want the ability to overwrite stuff from main configuration file.
                foreach ($innerConfig as $k => $v) {
                    if (!is_array($v)) {
                        unset($innerConfig[$k]);
                    }
                }

                // Store conformed configuration into temporary array for merging later.
                $config[] = $innerConfig;
            }

            // Combine/Merge/Overwrite compiled configuration with current.
            // Uses the splat operator on the arrays stored in the temporary config.
            $this->configuration = array_replace_recursive($this->configuration, ...$config);
        }

        // Fill in the placeholders.
        $this->configuration = $this->replacePlaceholders($this->configuration);
    }
}


1			<?php
2
3			namespace GeekLab\Conf;
4
5			use GeekLab\Conf\Driver\ConfDriverInterface;
6
7			final class GLConf
8			{
9			/** @var ConfDriverInterface $driver */
10			private $driver;
11
12			/** @var array $configuration The compiled configuration. */
13			protected $configuration = [];
14
15			/**
16			* GLConf constructor.
17			* Inject our driver (strategy) here.
18			*
19			* @param ConfDriverInterface $driver
20			*/
21			public function __construct(ConfDriverInterface $driver)
22			{
23			$this->driver = $driver;
24			}
25
26			/**
27			* Return the compiled configuration.
28			*
29			* @return array
30			*/
31			public function getAll(): array
32			{
33			return $this->configuration;
34			}
35
36			/**
37			* Get data by dot notation.
38			* Stolen from: https://stackoverflow.com/a/14706302/344028
39			*
40			* @param string $key dot notated array key accessor.
41			*
42			* @return mixed
43			*/
44			public function get(string $key)
45			{
46			/** @var string $key Convert key to upper case. */
47			$key = strtoupper($key);
48
49			/** @var mixed $config Save configuration for local scope modification. */
50			$config = $this->configuration;
51
52			/** @var bool\|array $token Tokenize the key to do iterations over the config with. */
53			$token = strtok($key, '.');
54
55			// Loop until we are out of tokens.
56			while ($token !== false) {
57			if (!isset($config[$token])) {
58			// Array key of $token wasn't found.
59			return false;
60			}
61
62			// Save the data found.
63			$config = $config[$token];
64
65			// Advanced to the next token, or set token to false if nothing else if left..
66			$token = strtok('.');
67			}
68
69			// Return the valid found by the previous loop.
70			return $config;
71			}
72
73			/**
74			* Make the array conform to some sort of standard.
75			* - Convert key names to uppercase.
76			* - Convert spaces and periods to underscores.
77			*
78			* @param array $arr
79			*
80			* @return array
81			*/
82			protected function conformArray(array $arr): array
83			{
84			// Store our conformed array for returning.
85			$fixed = [];
86
87			// Convert keys to uppercase.
88			$arr = array_change_key_case($arr, CASE_UPPER);
89
90			foreach ($arr as $k => $v) {
91			// Recursively conform the inner arrays.
92			if (is_array($v)) {
93			$v = $this->conformArray($v);
94			}
95
96			// Replace spaces and periods with underscores.
97			$fixed[preg_replace('/\s+\|\.+/', '_', $k)] = $v;
98			}
99
100			// Return the conformed array.
101			return $fixed;
102			}
103
104			/**
105			* @param array $data
106			* @return array
107			*/
108			private function arrayPlaceholderHandler(array $data): array
109			{
110			// It's an array, so let's loop through it.
111			foreach ($data as $k => $val) {
112			if (!is_array($val)) {
113			// Find the self referenced placeholders and fill them.
114			$data[$k] = preg_replace_callback('/@\[([a-zA-Z0-9_.-]*?)]/', function ($matches) {
115			// Does this key exist, is so fill this match, if not, just return the match intact.
116			return $this->get($matches[1]) ?: $matches[0];
117			}, $val);
118
119			// Find the recursive self referenced placeholders and fill them.
120			if ($data[$k] !== $val && preg_match('/@\[([a-zA-Z0-9_.-]*?)]/', $data[$k])) {
121			$data[$k] = $this->replacePlaceholders($data[$k]);
122			}
123
124			// Find the environment variable placeholders and fill them.
125			$data[$k] = preg_replace_callback('/\$\[([a-zA-Z0-9_.-]*?)]/', static function ($matches) {
126			// If locally set environment variable (variable not set by a SAPI) found, replace with it's value.
127			if (!empty(getenv($matches[1], true))) {
128			// Try local only environment variables first (variable not set by a SAPI)
129			$ret = getenv($matches[1], true);
130			} else {
131			// Don't replace.
132			$ret = $matches[0];
133			}
134
135			return $ret;
136			}, $data[$k]);
137			} else {
138			// Recursively replace placeholders.
139			$data[$k] = $this->replacePlaceholders($val);
140			}
141			}
142
143			return $data;
144			}
145
146			/**
147			* @param $data
148			* @return array
149			*/
150			private function stringPlaceholderHandler(string $data): string
151			{
152			// Find the self referenced placeholders and fill them.
153			return preg_replace_callback('/@\[([a-zA-Z0-9_.-]*?)]/', function ($matches) {
			0 ignored issues – show Bug Best Practice introduced 2019-06-19 00:17 UTC by Report Bug Copy Issue Report The expression `return preg_replace_call...) { /* ... */ }, $data)` returns the type `string` which is incompatible with the documented return type `array`. Loading history...
154			// Does this key exist, is so fill this match, if not, just return the match intact.
155			$ret = $this->get($matches[1]) ?: $matches[0];
156
157			// Looks like we have a recursive self referenced placeholder.
158			if ($ret !== $matches[0] && preg_match('/@\[(.*?)]/', $matches[0])) {
159			$ret = $this->replacePlaceholders($ret);
160			}
161
162			return $ret;
163			}, $data);
164			}
165			/**
166			* Self referenced and environment variable placeholder replacement.
167			*
168			* @param mixed $data
169			* @return mixed
170			*/
171			protected function replacePlaceholders($data)
172			{
173			if (is_array($data)) {
174			$data = $this->arrayPlaceholderHandler($data);
175			} elseif (is_string($data)) {
176			// It's a string!
177			// Certain recursive stuff, like @[SelfReferencedPlaceholder.@[SomeStuff.a]] is what triggers this part.
178			$data = $this->stringPlaceholderHandler($data);
179			}
180
181			return $data;
182			}
183
184
185			/**
186			* Initialize the configuration system.
187			*/
188			public function init(): void
189			{
190			// Load main (top level) configuration and conform it (uppercase and changes spaces to underscores in keys).
191			$this->configuration = $this->driver->parseConfigurationFile();
192			$this->configuration = $this->conformArray($this->configuration);
193			$config = [];
194
195			// Load in the extra configuration via the CONF property.
196			if (isset($this->configuration['CONF']) && is_array($this->configuration['CONF'])) {
197			foreach ($this->configuration['CONF'] as $file) {
198			// Load in the referenced configuration from the main configuration.
199			$innerConfig = $this->driver->parseConfigurationFile($file);
200
201			// Conform the configuration array.
202			$innerConfig = $this->conformArray($innerConfig);
203
204			// Strip out anything that wasn't in a section (non-array value at the top level).
205			// We don't want the ability to overwrite stuff from main configuration file.
206			foreach ($innerConfig as $k => $v) {
207			if (!is_array($v)) {
208			unset($innerConfig[$k]);
209			}
210			}
211
212			// Store conformed configuration into temporary array for merging later.
213			$config[] = $innerConfig;
214			}
215
216			// Combine/Merge/Overwrite compiled configuration with current.
217			// Uses the splat operator on the arrays stored in the temporary config.
218			$this->configuration = array_replace_recursive($this->configuration, ...$config);
219			}
220
221			// Fill in the placeholders.
222			$this->configuration = $this->replacePlaceholders($this->configuration);
223			}
224			}
225

ellisgl / GeekLab-Conf

Branch — master (29d251)

GLConf::stringPlaceholderHandler() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like