zfcampus / zf-configuration / 76

pending completion

Build # 76

Build Type

Pull #29

travis-ci

Committed by

web-flow

Commit Message

<a href="https://github.com/zfcampus/zf-configuration/commit/<a class=hub.com/zfcampus/zf-configuration/commit/<a class="double-link" href="https://git"><a class=hub.com/zfcampus/zf-configuration/commit/4c6b034adb7f9322db8f285bb63459ea94550e75">4c6b034ad<a href="https://github.com/zfcampus/zf-configuration/commit/4c6b034adb7f9322db8f285bb63459ea94550e75">&lt;a href=&quot;https://github.com/zfcampus/zf-configuration/commit/4c6b034adb7f9322db8f285bb63459ea94550e75">&quot;&gt;Revert &amp;quot;Merge pull request #25 from webimpress/hotfix/21&amp;quot;

This reverts commit &lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/zfcampus/zf-configuration/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/zfcampus/zf-configuration/commit/8e14178a2e2b3fbaa8e168aa69d1391ea9d57c02">8e14178a2</a>">8e14178a2</a><a href="https://github.com/zfcampus/zf-configuration/commit/4c6b034adb7f9322db8f285bb63459ea94550e75">, reversing
changes made to </a><a class="double-link" href="https://github.com/zfcampus/zf-configuration/commit/<a class="double-link" href="https://github.com/zfcampus/zf-configuration/commit/09f5af9b5eb91dffd45df48b05d0456292cc998c">09f5af9b5">09f5af9b5.

Fixes #28

Pull Request Pull Request #29: Revert backwards-incompatible changes

Run Details

10 of 10 new or added lines in 1 file covered. (100.0%)

109 of 197 relevant lines covered (55.33%)

2.5 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

78.85

/src/ConfigResource.php

<?php
/**
 * @license   http://opensource.org/licenses/BSD-3-Clause BSD-3-Clause
 * @copyright Copyright (c) 2014 Zend Technologies USA Inc. (http://www.zend.com)
 */

namespace ZF\Configuration;

use stdClass;
use Traversable;
use Zend\Config\Writer\WriterInterface as ConfigWriter;
use Zend\Stdlib\ArrayUtils;

class ConfigResource
{
    /**
     * @var array
     */
    protected $config;

    /**
     * File to which to write configuration
     *
     * @var string
     */
    protected $fileName;

    /**
     * Whether or not OpCache is enabled
     *
     * @var bool
     */
    protected $opcacheEnabled = false;

    /**
     * @var ConfigWriter
     */
    protected $writer;

    /**
     * @param array $config
     * @param string $fileName
     * @param ConfigWriter $writer
     */
    public function __construct(array $config, $fileName, ConfigWriter $writer)
    {
        $this->opcacheEnabled = function_exists('opcache_invalidate') && ini_get('opcache.enable');

        $this->config   = $config;
        $this->fileName = $fileName;
        $this->writer   = $writer;
    }

    /**
     * Allow patching one or more key/value pairs
     *
     * Expects data to be in the form of key/value pairs
     *
     * @param  array|stdClass|Traversable $data
     * @param  bool $tree
     * @return array
     */
    public function patch($data, $tree = false)
    {
        if ($data instanceof Traversable) {
            $data = ArrayUtils::iteratorToArray($data);
        }

        if ($data instanceof stdClass) {
            $data = (array) $data;
        }

        // Update configuration from dot-separated key/value pairs
        if (! $tree) {
            $patchValues = [];
            foreach ($data as $key => $value) {
                $this->createNestedKeyValuePair($patchValues, $key, $value);
            }
        } else {
            $patchValues = $data;
        }

        // Get local config file
        $localConfig = [];
        if (file_exists($this->fileName)) {
            $localConfig = include $this->fileName;
            if (! is_array($localConfig)) {
                $localConfig = [];
            }
        }
        $localConfig = ArrayUtils::merge($localConfig, $patchValues);

        // Write to configuration file
        $this->writer->toFile($this->fileName, $localConfig);
        $this->invalidateCache($this->fileName);

        // Reseed configuration
        $this->config = $localConfig;

        // Return written values
        return $data;
    }

    /**
     * Patch a single (potentially nested) key in the config file
     *
     * @param  string $key
     * @param  mixed $value
     * @return array
     */
    public function patchKey($key, $value)
    {
        // Get local config file
        $config = [];
        if (file_exists($this->fileName)) {
            $config = include $this->fileName;
            if (! is_array($config)) {
                $config = [];
            }
        }
        $config = $this->replaceKey($key, $value, $config);

        // Write to configuration file
        $this->writer->toFile($this->fileName, $config);
        $this->invalidateCache($this->fileName);

        // Reseed configuration
        $this->config = $config;

        // Return written values
        return $config;
    }

    /**
     * Overwrite configuration
     *
     * Used by consumers only; takes the configuration data and writes it verbatim.
     *
     * @param  array $data
     * @return array
     */
    public function overWrite(array $data)
    {
        $this->writer->toFile($this->fileName, $data);
        $this->invalidateCache($this->fileName);

        // Reseed configuration
        $this->config = $data;

        return $data;
    }

    /**
     * Fetch all configuration values
     *
     * Flattens nested configuration to dot-separated key/value pairs and returns them.
     *
     * @param  bool $tree
     * @return array
     */
    public function fetch($tree = false)
    {
        // If requested as a tree, return as-is
        if ($tree) {
            return $this->config;
        }

        // Collapse to key/value pairs -- meaning to dot-separated nested keys
        return $this->traverseArray($this->config);
    }

    /**
     * Replace a nested key
     *
     * First invocation should pass a dot-separated string representing a
     * nested key.
     *
     * This value will be exploded to a list of keys, and the first element of
     * the list will be compared against the provided configuration array; the
     * method will recurse as necessary in order to replace the key.
     *
     * @param  string|array $keys
     * @param  mixed $value
     * @param  array $config
     * @return array
     */
    public function replaceKey($keys, $value, array $config)
    {
        if (! is_array($keys)) {
            $keys = explode('.', $keys);
        }

        $key = array_shift($keys);

        // If no more keys, overwrite and return
        if (! $keys) {
            $config[$key] = $value;
            return $config;
        }

        // If key does not exist, or the current value is not an associative
        // array, create nested set and return
        if (! isset($config[$key])
            || ! ArrayUtils::isHashTable($config[$key])
        ) {
            $config[$key] = $this->replaceKey($keys, $value, []);
            return $config;
        }

        // Otherwise, recurse through it
        $config[$key] = $this->replaceKey($keys, $value, $config[$key]);
        return $config;
    }

    /**
     * Delete a key from the configuration array
     *
     * $key may be either an array of keys or a dot-separated set of keys.
     *
     * @param  array|string $keys
     * @return array
     */
    public function deleteKey($keys)
    {
        // Get local config file
        $config = [];
        if (file_exists($this->fileName)) {
            $config = include $this->fileName;
            if (! is_array($config)) {
                $config = [];
            }
        }

        if (! is_array($keys)) {
            $keys = explode('.', $keys);
        }

        if (empty($keys)) {
            return $config;
        }

        $this->deleteByKey($config, $keys);
        $this->writer->toFile($this->fileName, $config);
        $this->invalidateCache($this->fileName);

        // Reseed configuration
        $this->config = $config;

        return $config;
    }

    /**
     * Traverse a nested array and flatten to dot-separated key/value pairs
     *
     * @param  array $array
     * @param  string $currentKey Current key, if called recursively
     * @return array
     */
    public function traverseArray(array $array, $currentKey = '')
    {
        $flattened = [];
        foreach ($array as $key => $value) {
            $targetKey = ('' === $currentKey) ? $key : $currentKey . '.' . $key;
            if (is_array($value)) {
                $value = $this->traverseArray($value, $targetKey);
                $flattened = array_merge($flattened, $value);
                continue;
            }

            $flattened[$targetKey] = $value;
        }
        return $flattened;
    }

    /**
     * Create a nested key/value pair from a dot-separated key value pair
     *
     * Extracts the nested pair into the array provided in $patchValues
     *
     * @param array $patchValues
     * @param string $key
     * @param mixed $value
     * @throws Exception\InvalidArgumentException
     */
    public function createNestedKeyValuePair(&$patchValues, $key, $value)
    {
        if (! is_array($patchValues)) {
            throw new Exception\InvalidArgumentException(sprintf(
                '%s expects the $patchValues argument to be an array; received %s',
                __METHOD__,
                (is_object($patchValues) ? get_class($patchValues) : gettype($patchValues))
            ));
        }

        $this->extractAndSet(explode('.', $key), $value, $patchValues);
    }

    /**
     * Recursively extract keys into a nested array
     *
     * @param array $keys
     * @param string $value
     * @param array $array
     */
    protected function extractAndSet(array $keys, $value, &$array)
    {
        $key = array_shift($keys);
        if ($keys) {
            if (! isset($array[$key]) || ! is_array($array[$key])) {
                $array[$key] = [];
            }
            $reference   = &$array[$key];
            $this->extractAndSet($keys, $value, $reference);
            return;
        }
        $array[$key] = $value;
    }

    /**
     * Delete a nested key/value pair in an array
     *
     * @param  array $array
     * @param  array $keys
     */
    protected function deleteByKey(&$array, array $keys)
    {
        $key = array_shift($keys);
        if (! is_array($array) || ! array_key_exists($key, $array)) {
            return;
        }

        if (! $keys) {
            unset($array[$key]);
            return;
        }
        $this->deleteByKey($array[$key], $keys);
    }

    /**
     * Invalidate the opcache for a given file
     *
     * @param  string $filename
     */
    protected function invalidateCache($filename)
    {
        if (! $this->opcacheEnabled) {
            return;
        }

        opcache_invalidate($filename, true);
    }
}

1	<?php
2	/**
3	* @license http://opensource.org/licenses/BSD-3-Clause BSD-3-Clause
4	* @copyright Copyright (c) 2014 Zend Technologies USA Inc. (http://www.zend.com)
5	*/
6
7	namespace ZF\Configuration;
8
9	use stdClass;
10	use Traversable;
11	use Zend\Config\Writer\WriterInterface as ConfigWriter;
12	use Zend\Stdlib\ArrayUtils;
13
14	class ConfigResource
15	{
16	/**
17	* @var array
18	*/
19	protected $config;
20
21	/**
22	* File to which to write configuration
23	*
24	* @var string
25	*/
26	protected $fileName;
27
28	/**
29	* Whether or not OpCache is enabled
30	*
31	* @var bool
32	*/
33	protected $opcacheEnabled = false;
34
35	/**
36	* @var ConfigWriter
37	*/
38	protected $writer;
39
40	/**
41	* @param array $config
42	* @param string $fileName
43	* @param ConfigWriter $writer
44	*/
45	public function __construct(array $config, $fileName, ConfigWriter $writer)
46	{
47	$this->opcacheEnabled = function_exists('opcache_invalidate') && ini_get('opcache.enable');	25✔
48
49	$this->config = $config;	25✔
50	$this->fileName = $fileName;	25✔
51	$this->writer = $writer;	25✔
52	}	25✔
53
54	/**
55	* Allow patching one or more key/value pairs
56	*
57	* Expects data to be in the form of key/value pairs
58	*
59	* @param array\|stdClass\|Traversable $data
60	* @param bool $tree
61	* @return array
62	*/
63	public function patch($data, $tree = false)
64	{
65	if ($data instanceof Traversable) {	2✔
66	$data = ArrayUtils::iteratorToArray($data);	×
67	}
68
69	if ($data instanceof stdClass) {	2✔
70	$data = (array) $data;	×
71	}
72
73	// Update configuration from dot-separated key/value pairs
74	if (! $tree) {	2✔
75	$patchValues = [];	1✔
76	foreach ($data as $key => $value) {	1✔
77	$this->createNestedKeyValuePair($patchValues, $key, $value);	1✔
78	}
79	} else {
80	$patchValues = $data;	1✔
81	}
82
83	// Get local config file
84	$localConfig = [];	2✔
85	if (file_exists($this->fileName)) {	2✔
86	$localConfig = include $this->fileName;	2✔
87	if (! is_array($localConfig)) {	2✔
88	$localConfig = [];	×
89	}
90	}
91	$localConfig = ArrayUtils::merge($localConfig, $patchValues);	2✔
92
93	// Write to configuration file
94	$this->writer->toFile($this->fileName, $localConfig);	2✔
95	$this->invalidateCache($this->fileName);	2✔
96
97	// Reseed configuration
98	$this->config = $localConfig;	2✔
99
100	// Return written values
101	return $data;	2✔
102	}
103
104	/**
105	* Patch a single (potentially nested) key in the config file
106	*
107	* @param string $key
108	* @param mixed $value
109	* @return array
110	*/
111	public function patchKey($key, $value)
112	{
113	// Get local config file
114	$config = [];	×
115	if (file_exists($this->fileName)) {	×
116	$config = include $this->fileName;	×
117	if (! is_array($config)) {	×
118	$config = [];	×
119	}
120	}
121	$config = $this->replaceKey($key, $value, $config);	×
122
123	// Write to configuration file
124	$this->writer->toFile($this->fileName, $config);	×
125	$this->invalidateCache($this->fileName);	×
126
127	// Reseed configuration
128	$this->config = $config;	×
129
130	// Return written values
131	return $config;	×
132	}
133
134	/**
135	* Overwrite configuration
136	*
137	* Used by consumers only; takes the configuration data and writes it verbatim.
138	*
139	* @param array $data
140	* @return array
141	*/
142	public function overWrite(array $data)
143	{
144	$this->writer->toFile($this->fileName, $data);	1✔
145	$this->invalidateCache($this->fileName);	1✔
146
147	// Reseed configuration
148	$this->config = $data;	1✔
149
150	return $data;	1✔
151	}
152
153	/**
154	* Fetch all configuration values
155	*
156	* Flattens nested configuration to dot-separated key/value pairs and returns them.
157	*
158	* @param bool $tree
159	* @return array
160	*/
161	public function fetch($tree = false)
162	{
163	// If requested as a tree, return as-is
164	if ($tree) {	3✔
165	return $this->config;	2✔
166	}
167
168	// Collapse to key/value pairs -- meaning to dot-separated nested keys
169	return $this->traverseArray($this->config);	1✔
170	}
171
172	/**
173	* Replace a nested key
174	*
175	* First invocation should pass a dot-separated string representing a
176	* nested key.
177	*
178	* This value will be exploded to a list of keys, and the first element of
179	* the list will be compared against the provided configuration array; the
180	* method will recurse as necessary in order to replace the key.
181	*
182	* @param string\|array $keys
183	* @param mixed $value
184	* @param array $config
185	* @return array
186	*/
187	public function replaceKey($keys, $value, array $config)
188	{
189	if (! is_array($keys)) {	7✔
190	$keys = explode('.', $keys);	7✔
191	}
192
193	$key = array_shift($keys);	7✔
194
195	// If no more keys, overwrite and return
196	if (! $keys) {	7✔
197	$config[$key] = $value;	7✔
198	return $config;	7✔
199	}
200
201	// If key does not exist, or the current value is not an associative
202	// array, create nested set and return
203	if (! isset($config[$key])	5✔
204	\|\| ! ArrayUtils::isHashTable($config[$key])	5✔
205	) {
206	$config[$key] = $this->replaceKey($keys, $value, []);	×
207	return $config;	×
208	}
209
210	// Otherwise, recurse through it
211	$config[$key] = $this->replaceKey($keys, $value, $config[$key]);	5✔
212	return $config;	5✔
213	}
214
215	/**
216	* Delete a key from the configuration array
217	*
218	* $key may be either an array of keys or a dot-separated set of keys.
219	*
220	* @param array\|string $keys
221	* @return array
222	*/
223	public function deleteKey($keys)
224	{
225	// Get local config file
226	$config = [];	7✔
227	if (file_exists($this->fileName)) {	7✔
228	$config = include $this->fileName;	7✔
229	if (! is_array($config)) {	7✔
230	$config = [];	×
231	}
232	}
233
234	if (! is_array($keys)) {	7✔
235	$keys = explode('.', $keys);	6✔
236	}
237
238	if (empty($keys)) {	7✔
239	return $config;	×
240	}
241
242	$this->deleteByKey($config, $keys);	7✔
243	$this->writer->toFile($this->fileName, $config);	7✔
244	$this->invalidateCache($this->fileName);	7✔
245
246	// Reseed configuration
247	$this->config = $config;	7✔
248
249	return $config;	7✔
250	}
251
252	/**
253	* Traverse a nested array and flatten to dot-separated key/value pairs
254	*
255	* @param array $array
256	* @param string $currentKey Current key, if called recursively
257	* @return array
258	*/
259	public function traverseArray(array $array, $currentKey = '')
260	{
261	$flattened = [];	2✔
262	foreach ($array as $key => $value) {	2✔
263	$targetKey = ('' === $currentKey) ? $key : $currentKey . '.' . $key;	2✔
264	if (is_array($value)) {	2✔
265	$value = $this->traverseArray($value, $targetKey);	2✔
266	$flattened = array_merge($flattened, $value);	2✔
267	continue;	2✔
268	}
269
270	$flattened[$targetKey] = $value;	2✔
271	}
272	return $flattened;	2✔
273	}
274
275	/**
276	* Create a nested key/value pair from a dot-separated key value pair
277	*
278	* Extracts the nested pair into the array provided in $patchValues
279	*
280	* @param array $patchValues
281	* @param string $key
282	* @param mixed $value
283	* @throws Exception\InvalidArgumentException
284	*/
285	public function createNestedKeyValuePair(&$patchValues, $key, $value)
286	{
287	if (! is_array($patchValues)) {	2✔
288	throw new Exception\InvalidArgumentException(sprintf(	×
289	'%s expects the $patchValues argument to be an array; received %s',	×
290	__METHOD__,	×
291	(is_object($patchValues) ? get_class($patchValues) : gettype($patchValues))	×
292	));
293	}
294
295	$this->extractAndSet(explode('.', $key), $value, $patchValues);	2✔
296	}	2✔
297
298	/**
299	* Recursively extract keys into a nested array
300	*
301	* @param array $keys
302	* @param string $value
303	* @param array $array
304	*/
305	protected function extractAndSet(array $keys, $value, &$array)
306	{
307	$key = array_shift($keys);	2✔
308	if ($keys) {	2✔
309	if (! isset($array[$key]) \|\| ! is_array($array[$key])) {	2✔
310	$array[$key] = [];	2✔
311	}
312	$reference = &$array[$key];	2✔
313	$this->extractAndSet($keys, $value, $reference);	2✔
314	return;	2✔
315	}
316	$array[$key] = $value;	2✔
317	}	2✔
318
319	/**
320	* Delete a nested key/value pair in an array
321	*
322	* @param array $array
323	* @param array $keys
324	*/
325	protected function deleteByKey(&$array, array $keys)
326	{
327	$key = array_shift($keys);	7✔
328	if (! is_array($array) \|\| ! array_key_exists($key, $array)) {	7✔
329	return;	1✔
330	}
331
332	if (! $keys) {	6✔
333	unset($array[$key]);	6✔
334	return;	6✔
335	}
336	$this->deleteByKey($array[$key], $keys);	4✔
337	}	4✔
338
339	/**
340	* Invalidate the opcache for a given file
341	*
342	* @param string $filename
343	*/
344	protected function invalidateCache($filename)
345	{
346	if (! $this->opcacheEnabled) {	10✔
347	return;	×
348	}
349
350	opcache_invalidate($filename, true);	10✔
351	}	10✔
352	}

zfcampus / zf-configuration / 76

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous