Config::encodeArray() - Code Metrics - Inspection of "Split Config::dataEncode into seperate function" - benrowe/laravel-config - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — dev ( d75f3f...7b5e19 )

by Ben

created 2016-05-13 07:55 UTC

Config::encodeArray() A

↳ Parent: Config

Complexity

Conditions	3
Paths	3

Size

Total Lines	11
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	11
rs	9.4285
cc	3
eloc	7
nc	3
nop	3

<?php

namespace Benrowe\Laravel\Config;

use Illuminate\Support\Arr;

/**
 * Config class
 * Transforms a flattened key/value array configuration into a multi-dimensional
 * config handler
 */
class Config
{
    /**
     * @var string The delimiter used in the array keys to specify the heirachy
     */
    const KEY_DELIMITER = '.';

    /**
     * @var string the pattern to match array keys
     */
    const ARRAY_PATTERN = "/\[([0-9]+)\]$/";

    /**
     * The configuration data
     * @var array
     */
    private $data;

    /**
     * constructor
     * The initial data
     *
     * @param array $data the flattened data
     */
    public function __construct($data)
    {
        $this->data = $this->dataDecode($data);
    }

    /**
     * Reduce the configuration to a simple key/value array, despite the heirachy
     * of information
     *
     * @return array
     */
    public function flatten()
    {
        return $this->dataEncode($this->data);
    }

    /**
     * Create/Update a configuration value
     *
     * @param string $key
     * @param mixed $value
     */
    public function set($key, $value)
    {
        Arr::set($this->data, $key, $value);
    }

    /**
     * Get the configuration value based on it's key
     *
     * @param  string $key
     * @param  mixed $default
     * @return mixed
     */
    public function get($key, $default = null)
    {
        return Arr::get($this->data, $key, $default);
    }

    /**
     * From an item from the configuration
     *
     * @param  string $key
     * @return boolean
     */
    public function forget($key)
    {
        return Arr::forget($this->data, $key);
    }

    /**
     * Clear all of the settings from the configuration
     *
     * @return boolean
     */
    public function clear()
    {
        if (!empty($this->data)) {
            $this->data = [];
            return true;
        }
        return false;
    }

    /**
     * Check if a configuration setting exists
     *
     * @param  string $key
     * @return boolean
     */
    public function exists($key)
    {
        return Arr::has($this->data, $key);
    }

    /**
     * Converts the flat key/value from the storage engine
     * to a heirachy structure based on the key sytax
     *
     * @param  array $data
     * @return array
     */
    private function dataDecode($data)
    {
        // preprocess the keys into a unique list where the array values are
        // stored against the same key

        $data = $this->unpackArray($data);

        $newData = [];
        foreach ($data as $key => $value) {
            Arr::set($newData, $key, $value);
        }

        return $newData;
    }

    /**
     * unpack the keys that are structured for arrays so that they no
     * longer have the [] syntax at the end. Rather they're now a proper
     * array.
     *
     * @param  array $data [description]
     * @return array
     */
    private function unpackArray($data)
    {
        $arrKeys = array_filter($data, function ($val) {
            return preg_match(self::ARRAY_PATTERN, $val);
        });
        foreach ($arrKeys as $key => $value) {
            $newKey = preg_replace(self::ARRAY_PATTERN, '', $key);
            if (!isset($data[$newKey])) {
                $data[$newKey] = [];
            }
            $data[$newKey][] = $value;
            unset($data[$key]);
        }
        return $data;
    }

    /**
     * Flatten a multi-dimensional array into a linear key/value list
     *
     * @param  array $data
     * @return array
     */
    private function dataEncode($data, $prefix = null)
    {
        $newData = [];
        foreach ($data as $key => $value) {
            if (is_array($value)) {
                $newData = array_merge($newData, $this->encodeArray($key, $value, $prefix));
                continue;
            }
            $newData[$prefix.$key] = $value;
        }
        return $newData;
    }

    /**
     * Encode the array of values against the provided key
     *
     * @param  string $key
     * @param  array  $value  either an associative or keyed array
     * @param  string $prefix
     * @return array
     */
    private function encodeArray($key, array $value, $prefix = null)
    {
        $data = [];
        if (!Arr::isAssoc($value)) {
            foreach ($value as $index => $val) {
                $data[$prefix.$key.'['.$index.']'] = $val;
            }
            return $data;
        }
        return $this->dataEncode($value, $prefix.$key.self::KEY_DELIMITER);
    }
}


1			<?php
2
3			namespace Benrowe\Laravel\Config;
4
5			use Illuminate\Support\Arr;
6
7			/**
8			* Config class
9			* Transforms a flattened key/value array configuration into a multi-dimensional
10			* config handler
11			*/
12			class Config
13			{
14			/**
15			* @var string The delimiter used in the array keys to specify the heirachy
16			*/
17			const KEY_DELIMITER = '.';
18
19			/**
20			* @var string the pattern to match array keys
21			*/
22			const ARRAY_PATTERN = "/\[([0-9]+)\]$/";
23
24			/**
25			* The configuration data
26			* @var array
27			*/
28			private $data;
29
30			/**
31			* constructor
32			* The initial data
33			*
34			* @param array $data the flattened data
35			*/
36			public function __construct($data)
37			{
38			$this->data = $this->dataDecode($data);
39			}
40
41			/**
42			* Reduce the configuration to a simple key/value array, despite the heirachy
43			* of information
44			*
45			* @return array
46			*/
47			public function flatten()
48			{
49			return $this->dataEncode($this->data);
50			}
51
52			/**
53			* Create/Update a configuration value
54			*
55			* @param string $key
56			* @param mixed $value
57			*/
58			public function set($key, $value)
59			{
60			Arr::set($this->data, $key, $value);
61			}
62
63			/**
64			* Get the configuration value based on it's key
65			*
66			* @param string $key
67			* @param mixed $default
68			* @return mixed
69			*/
70			public function get($key, $default = null)
71			{
72			return Arr::get($this->data, $key, $default);
73			}
74
75			/**
76			* From an item from the configuration
77			*
78			* @param string $key
79			* @return boolean
80			*/
81			public function forget($key)
82			{
83			return Arr::forget($this->data, $key);
84			}
85
86			/**
87			* Clear all of the settings from the configuration
88			*
89			* @return boolean
90			*/
91			public function clear()
92			{
93			if (!empty($this->data)) {
94			$this->data = [];
95			return true;
96			}
97			return false;
98			}
99
100			/**
101			* Check if a configuration setting exists
102			*
103			* @param string $key
104			* @return boolean
105			*/
106			public function exists($key)
107			{
108			return Arr::has($this->data, $key);
109			}
110
111			/**
112			* Converts the flat key/value from the storage engine
113			* to a heirachy structure based on the key sytax
114			*
115			* @param array $data
116			* @return array
117			*/
118			private function dataDecode($data)
119			{
120			// preprocess the keys into a unique list where the array values are
121			// stored against the same key
122
123			$data = $this->unpackArray($data);
124
125			$newData = [];
126			foreach ($data as $key => $value) {
127			Arr::set($newData, $key, $value);
128			}
129
130			return $newData;
131			}
132
133			/**
134			* unpack the keys that are structured for arrays so that they no
135			* longer have the [] syntax at the end. Rather they're now a proper
136			* array.
137			*
138			* @param array $data [description]
139			* @return array
140			*/
141			private function unpackArray($data)
142			{
143			$arrKeys = array_filter($data, function ($val) {
144			return preg_match(self::ARRAY_PATTERN, $val);
145			});
146			foreach ($arrKeys as $key => $value) {
147			$newKey = preg_replace(self::ARRAY_PATTERN, '', $key);
148			if (!isset($data[$newKey])) {
149			$data[$newKey] = [];
150			}
151			$data[$newKey][] = $value;
152			unset($data[$key]);
153			}
154			return $data;
155			}
156
157			/**
158			* Flatten a multi-dimensional array into a linear key/value list
159			*
160			* @param array $data
161			* @return array
162			*/
163			private function dataEncode($data, $prefix = null)
164			{
165			$newData = [];
166			foreach ($data as $key => $value) {
167			if (is_array($value)) {
168			$newData = array_merge($newData, $this->encodeArray($key, $value, $prefix));
169			continue;
170			}
171			$newData[$prefix.$key] = $value;
172			}
173			return $newData;
174			}
175
176			/**
177			* Encode the array of values against the provided key
178			*
179			* @param string $key
180			* @param array $value either an associative or keyed array
181			* @param string $prefix
182			* @return array
183			*/
184			private function encodeArray($key, array $value, $prefix = null)
185			{
186			$data = [];
187			if (!Arr::isAssoc($value)) {
188			foreach ($value as $index => $val) {
189			$data[$prefix.$key.'['.$index.']'] = $val;
190			}
191			return $data;
192			}
193			return $this->dataEncode($value, $prefix.$key.self::KEY_DELIMITER);
194			}
195			}
196

benrowe / laravel-config

Push — dev ( d75f3f...7b5e19 )

Config::encodeArray() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like