Config::setDelegator() - Code Metrics - Inspection of "fixed bug in setDelegator()" - phossa2/config - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( d9f26b...85f62f )

by Hong

created 2016-07-10 01:17 UTC

Config::setDelegator() A

↳ Parent: Config

Complexity

Conditions	1
Paths	1

Size

Total Lines	5
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	1	Features	0

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

<?php
/**
 * Phossa Project
 *
 * PHP version 5.4
 *
 * @category  Library
 * @package   Phossa2\Config
 * @copyright Copyright (c) 2016 phossa.com
 * @license   http://mit-license.org/ MIT License
 * @link      http://www.phossa.com/
 */
/*# declare(strict_types=1); */

namespace Phossa2\Config;

use Phossa2\Shared\Tree\Tree;
use Phossa2\Config\Message\Message;
use Phossa2\Config\Loader\DummyLoader;
use Phossa2\Shared\Tree\TreeInterface;
use Phossa2\Shared\Base\ObjectAbstract;
use Phossa2\Config\Traits\WritableTrait;
use Phossa2\Config\Traits\ArrayAccessTrait;
use Phossa2\Shared\Reference\ReferenceTrait;
use Phossa2\Config\Exception\LogicException;
use Phossa2\Config\Interfaces\ConfigInterface;
use Phossa2\Config\Loader\ConfigLoaderInterface;
use Phossa2\Shared\Reference\ReferenceInterface;
use Phossa2\Config\Interfaces\WritableInterface;
use Phossa2\Shared\Reference\DelegatorInterface;
use Phossa2\Shared\Reference\DelegatorAwareTrait;
use Phossa2\Shared\Reference\DelegatorAwareInterface;

/**
 * Config
 *
 * @package Phossa2\Config
 * @author  Hong Zhang <[email protected]>
 * @see     ObjectAbstract
 * @see     \ArrayAccess
 * @see     ConfigInterface
 * @see     ReferenceInterface
 * @see     DelegatorAwareInterface
 * @version 2.0.0
 * @since   2.0.0 added
 */
class Config extends ObjectAbstract implements \ArrayAccess, ConfigInterface, WritableInterface, ReferenceInterface, DelegatorAwareInterface
{
    use ReferenceTrait, DelegatorAwareTrait, ArrayAccessTrait, WritableTrait;

    /**
     * error type
     *
     * @var    int
     */
    const ERROR_IGNORE    = 0;
    const ERROR_WARNING   = 1;
    const ERROR_EXCEPTION = 2;

    /**
     * the config loader
     *
     * @var    ConfigLoaderInterface
     * @access protected
     */
    protected $loader;

    /**
     * the config tree
     *
     * @var    TreeInterface
     * @access protected
     */
    protected $config;

    /**
     * cache loaded group names
     *
     * @var    array
     * @access protected
     */
    protected $loaded = [];

    /**
     * How to dealing with error, ignore/trigger_error/exception etc.
     *
     * @var    int
     * @access protected
     */
    protected $error_type = self::ERROR_WARNING;

    /**
     * Constructor
     *
     * @param  ConfigLoaderInterface $loader
     * @param  TreeInterface $configTree
     * @param  array $configData using this data if provided
     * @access public
     * @api
     */
    public function __construct(
        ConfigLoaderInterface $loader = null,
        TreeInterface $configTree = null,
        array $configData = []
    ) {
        $this->loader = $loader ?: new DummyLoader();
        $this->config = $configTree ?: new Tree($configData);
    }

    /**
     * {@inheritDoc}
     */
    public function get(/*# string */ $key, $default = null)
    {
        try {
            // lazy load
            $this->loadConfig((string) $key);

            //  get value
            $val = $this->config->getNode((string) $key);

            // dereference
            $this->deReferenceArray($val);

            return null === $val ? $default : $val;

        // if dereference exception catched
        } catch (\Exception $e) {
            $this->throwError($e->getMessage(), $e->getCode());
            return $default;
        }
    }

    /**
     * {@inheritDoc}
     */
    public function has(/*# string */ $key)/*# : bool */
    {
        try {
            // update error type
            $err = $this->error_type;
            $this->setErrorType(self::ERROR_IGNORE);

            // lazy load
            $this->loadConfig((string) $key);

            //  get value
            $result = null !== $this->config->getNode((string) $key);

            // restore error type
            $this->setErrorType($err);

            return $result;

        } catch (\Exception $e) {
            return false;
        }
    }

    /**
     * {@inheritDoc}
     */
    public function set(/*# string */ $key, $value)
    {
        if ($this->isWritable()) {
            // lazy load, no dereference
            $this->loadConfig((string) $key);

            // replace the node
            $this->config->addNode($key, $value);

            return $this;
        }
        $this->throwError(
            Message::get(Message::CONFIG_NOT_WRITABLE),
            Message::CONFIG_NOT_WRITABLE
        );
    }

    /**
     * Set error type
     *
     * @param  int $type
     * @return $this
     * @access public
     * @api
     */
    public function setErrorType(/*# int */ $type)
    {
        $this->error_type = $type;
        return $this;
    }

    /**
     * Overwrite setDelegator() in DelegatorAwareTrait
     * {@inheritDoc}
     */
    public function setDelegator(DelegatorInterface $delegator)
    {
        $this->delegator = $delegator->addRegistry($this);
        return $this;
    }

    /**
     * Load config
     *
     * @param  string $key
     * @return $this
     * @throws LogicException if current $error_type is to throw exception
     * @access protected
     */
    protected function loadConfig(/*# string */ $key)
    {
        // get group name
        $group = $this->getGroupName($key);

        // $group loaded ?
        if (isset($this->loaded[$group])) {
            return $this;
        }

        // mark as loaded
        $this->loaded[$group] = true;

        // loading the group
        return $this->loadByGroup($group);
    }

    /**
     * Load one group config, force loading all groups if $group == ''
     *
     * @param  string $group
     * @return $this
     * @throws \Exception group loading issues
     * @access protected
     */
    protected function loadByGroup(/*# string */ $group)
    {
        // if super global
        if (substr($group, 0, 1) === '_') {
            return $this->loadGlobal($group);
        }

        // load from config file
        $conf = $this->loader->load($group);

        foreach ($conf as $grp => $data) {
            $this->config->addNode($grp, $data);
        }

        return $this;
    }

    /**
     * Load super globals
     *
     * @param  string $group
     * @return $this
     * @throws LogicException if global unknown
     * @access protected
     */
    protected function loadGlobal(/*# string */ $group)
    {
        if (!isset($GLOBALS[$group])) {
            throw new LogicException(
                Message::get(Message::CONFIG_GLOBAL_UNKNOWN, $group),
                Message::CONFIG_GLOBAL_UNKNOWN
            );
        }

        // load super global
        $this->config->addNode($group, $GLOBALS[$group]);

        return $this;
    }

    /**
     * Get group name
     *
     * @param  string $key
     * @return string
     * @access protected
     */
    protected function getGroupName(/*# string */ $key)/*# : string */
    {
        // first field of the $key
        return explode($this->config->getDelimiter(), $key)[0];
    }

    /**
     * throw exception if current $error_type is to throw exception
     *
     * {@inheritDoc}
     */
    protected function resolveUnknown(/*# string */ $name)
    {
        // warn if reference unknown
        $this->throwError(
            Message::get(Message::CONFIG_REFERENCE_UNKNOWN, $name),
            Message::CONFIG_REFERENCE_UNKNOWN
        );

        return null;
    }

    /**
     * {@inheritDoc}
     */
    protected function getReference(/*# string */ $name)
    {
        return $this->get($name);
    }

    /**
     * Dealing errors
     *
     * @param  string $message
     * @param  int $code
     * @return $this
     * @throws LogicException if current $error_type is to throw exception
     * @access protected
     */
    protected function throwError(/*# string */ $message, /*# int */ $code)
    {
        switch ($this->error_type) {
            case self::ERROR_WARNING:
                trigger_error($message, \E_USER_WARNING);
                break;
            case self::ERROR_EXCEPTION:
                throw new LogicException($message, $code);
            default:
                break;
        }
        return $this;
    }
}


1			<?php
2			/**
3			* Phossa Project
4			*
5			* PHP version 5.4
6			*
7			* @category Library
8			* @package Phossa2\Config
9			* @copyright Copyright (c) 2016 phossa.com
10			* @license http://mit-license.org/ MIT License
11			* @link http://www.phossa.com/
12			*/
13			/# declare(strict_types=1); /
14
15			namespace Phossa2\Config;
16
17			use Phossa2\Shared\Tree\Tree;
18			use Phossa2\Config\Message\Message;
19			use Phossa2\Config\Loader\DummyLoader;
20			use Phossa2\Shared\Tree\TreeInterface;
21			use Phossa2\Shared\Base\ObjectAbstract;
22			use Phossa2\Config\Traits\WritableTrait;
23			use Phossa2\Config\Traits\ArrayAccessTrait;
24			use Phossa2\Shared\Reference\ReferenceTrait;
25			use Phossa2\Config\Exception\LogicException;
26			use Phossa2\Config\Interfaces\ConfigInterface;
27			use Phossa2\Config\Loader\ConfigLoaderInterface;
28			use Phossa2\Shared\Reference\ReferenceInterface;
29			use Phossa2\Config\Interfaces\WritableInterface;
30			use Phossa2\Shared\Reference\DelegatorInterface;
31			use Phossa2\Shared\Reference\DelegatorAwareTrait;
32			use Phossa2\Shared\Reference\DelegatorAwareInterface;
33
34			/**
35			* Config
36			*
37			* @package Phossa2\Config
38			* @author Hong Zhang <[email protected]>
39			* @see ObjectAbstract
40			* @see \ArrayAccess
41			* @see ConfigInterface
42			* @see ReferenceInterface
43			* @see DelegatorAwareInterface
44			* @version 2.0.0
45			* @since 2.0.0 added
46			*/
47			class Config extends ObjectAbstract implements \ArrayAccess, ConfigInterface, WritableInterface, ReferenceInterface, DelegatorAwareInterface
48			{
49			use ReferenceTrait, DelegatorAwareTrait, ArrayAccessTrait, WritableTrait;
50
51			/**
52			* error type
53			*
54			* @var int
55			*/
56			const ERROR_IGNORE = 0;
57			const ERROR_WARNING = 1;
58			const ERROR_EXCEPTION = 2;
59
60			/**
61			* the config loader
62			*
63			* @var ConfigLoaderInterface
64			* @access protected
65			*/
66			protected $loader;
67
68			/**
69			* the config tree
70			*
71			* @var TreeInterface
72			* @access protected
73			*/
74			protected $config;
75
76			/**
77			* cache loaded group names
78			*
79			* @var array
80			* @access protected
81			*/
82			protected $loaded = [];
83
84			/**
85			* How to dealing with error, ignore/trigger_error/exception etc.
86			*
87			* @var int
88			* @access protected
89			*/
90			protected $error_type = self::ERROR_WARNING;
91
92			/**
93			* Constructor
94			*
95			* @param ConfigLoaderInterface $loader
96			* @param TreeInterface $configTree
97			* @param array $configData using this data if provided
98			* @access public
99			* @api
100			*/
101			public function __construct(
102			ConfigLoaderInterface $loader = null,
103			TreeInterface $configTree = null,
104			array $configData = []
105			) {
106			$this->loader = $loader ?: new DummyLoader();
107			$this->config = $configTree ?: new Tree($configData);
108			}
109
110			/**
111			* {@inheritDoc}
112			*/
113			public function get(/# string / $key, $default = null)
114			{
115			try {
116			// lazy load
117			$this->loadConfig((string) $key);
118
119			// get value
120			$val = $this->config->getNode((string) $key);
121
122			// dereference
123			$this->deReferenceArray($val);
124
125			return null === $val ? $default : $val;
126
127			// if dereference exception catched
128			} catch (\Exception $e) {
129			$this->throwError($e->getMessage(), $e->getCode());
130			return $default;
131			}
132			}
133
134			/**
135			* {@inheritDoc}
136			*/
137			public function has(/# string / $key)/# : bool /
138			{
139			try {
140			// update error type
141			$err = $this->error_type;
142			$this->setErrorType(self::ERROR_IGNORE);
143
144			// lazy load
145			$this->loadConfig((string) $key);
146
147			// get value
148			$result = null !== $this->config->getNode((string) $key);
149
150			// restore error type
151			$this->setErrorType($err);
152
153			return $result;
154
155			} catch (\Exception $e) {
156			return false;
157			}
158			}
159
160			/**
161			* {@inheritDoc}
162			*/
163			public function set(/# string / $key, $value)
164			{
165			if ($this->isWritable()) {
166			// lazy load, no dereference
167			$this->loadConfig((string) $key);
168
169			// replace the node
170			$this->config->addNode($key, $value);
171
172			return $this;
173			}
174			$this->throwError(
175			Message::get(Message::CONFIG_NOT_WRITABLE),
176			Message::CONFIG_NOT_WRITABLE
177			);
178			}
179
180			/**
181			* Set error type
182			*
183			* @param int $type
184			* @return $this
185			* @access public
186			* @api
187			*/
188			public function setErrorType(/# int / $type)
189			{
190			$this->error_type = $type;
191			return $this;
192			}
193
194			/**
195			* Overwrite setDelegator() in DelegatorAwareTrait
196			* {@inheritDoc}
197			*/
198			public function setDelegator(DelegatorInterface $delegator)
199			{
200			$this->delegator = $delegator->addRegistry($this);
201			return $this;
202			}
203
204			/**
205			* Load config
206			*
207			* @param string $key
208			* @return $this
209			* @throws LogicException if current $error_type is to throw exception
210			* @access protected
211			*/
212			protected function loadConfig(/# string / $key)
213			{
214			// get group name
215			$group = $this->getGroupName($key);
216
217			// $group loaded ?
218			if (isset($this->loaded[$group])) {
219			return $this;
220			}
221
222			// mark as loaded
223			$this->loaded[$group] = true;
224
225			// loading the group
226			return $this->loadByGroup($group);
227			}
228
229			/**
230			* Load one group config, force loading all groups if $group == ''
231			*
232			* @param string $group
233			* @return $this
234			* @throws \Exception group loading issues
235			* @access protected
236			*/
237			protected function loadByGroup(/# string / $group)
238			{
239			// if super global
240			if (substr($group, 0, 1) === '_') {
241			return $this->loadGlobal($group);
242			}
243
244			// load from config file
245			$conf = $this->loader->load($group);
246
247			foreach ($conf as $grp => $data) {
248			$this->config->addNode($grp, $data);
249			}
250
251			return $this;
252			}
253
254			/**
255			* Load super globals
256			*
257			* @param string $group
258			* @return $this
259			* @throws LogicException if global unknown
260			* @access protected
261			*/
262			protected function loadGlobal(/# string / $group)
263			{
264			if (!isset($GLOBALS[$group])) {
265			throw new LogicException(
266			Message::get(Message::CONFIG_GLOBAL_UNKNOWN, $group),
267			Message::CONFIG_GLOBAL_UNKNOWN
268			);
269			}
270
271			// load super global
272			$this->config->addNode($group, $GLOBALS[$group]);
273
274			return $this;
275			}
276
277			/**
278			* Get group name
279			*
280			* @param string $key
281			* @return string
282			* @access protected
283			*/
284			protected function getGroupName(/# string / $key)/# : string /
285			{
286			// first field of the $key
287			return explode($this->config->getDelimiter(), $key)[0];
288			}
289
290			/**
291			* throw exception if current $error_type is to throw exception
292			*
293			* {@inheritDoc}
294			*/
295			protected function resolveUnknown(/# string / $name)
296			{
297			// warn if reference unknown
298			$this->throwError(
299			Message::get(Message::CONFIG_REFERENCE_UNKNOWN, $name),
300			Message::CONFIG_REFERENCE_UNKNOWN
301			);
302
303			return null;
304			}
305
306			/**
307			* {@inheritDoc}
308			*/
309			protected function getReference(/# string / $name)
310			{
311			return $this->get($name);
312			}
313
314			/**
315			* Dealing errors
316			*
317			* @param string $message
318			* @param int $code
319			* @return $this
320			* @throws LogicException if current $error_type is to throw exception
321			* @access protected
322			*/
323			protected function throwError(/# string / $message, /# int / $code)
324			{
325			switch ($this->error_type) {
326			case self::ERROR_WARNING:
327			trigger_error($message, \E_USER_WARNING);
328			break;
329			case self::ERROR_EXCEPTION:
330			throw new LogicException($message, $code);
331			default:
332			break;
333			}
334			return $this;
335			}
336			}
337

phossa2 / config

GitHub Access Token became invalid

Push — master ( d9f26b...85f62f )

Config::setDelegator() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like