Config::setErrorType() - Code Metrics - phossa2/libs - Measure and Improve Code Quality continuously with Scrutinizer

Config::setErrorType() A
last analyzed 2016-10-12 00:59 UTC

↳ Parent: Config

Complexity

Conditions	1
Paths	1

Size

Total Lines	5
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	5
rs	9.4285
c	0
b	0
f	0
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\Delegator\DelegatorAwareTrait;
use Phossa2\Shared\Delegator\DelegatorAwareInterface;

/**
 * Config
 *
 * @package Phossa2\Config
 * @author  Hong Zhang <[email protected]>
 * @see     ObjectAbstract
 * @see     ConfigInterface
 * @see     WritableInterface
 * @see     \ArrayAccess
 * @see     ReferenceInterface
 * @see     DelegatorAwareInterface
 * @version 2.1.0
 * @since   2.0.0 added
 * @since   2.0.7 changed DelegatorAware* stuff
 * @since   2.0.10 using recursive getDelegator
 * @since   2.0.12 changed `set()` return value
 */
class Config extends ObjectAbstract implements ConfigInterface, WritableInterface, \ArrayAccess, 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;

    /**
     * @var    string
     * @access private
     */
    private $cached_id;

    /**
     * @var    mixed
     * @access private
     */
    private $cached_value;

    /**
     * Constructor
     *
     * @param  ConfigLoaderInterface $loader config loader if any
     * @param  TreeInterface $configTree config tree if any
     * @param  array $configData config data for the tree
     * @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 */ $id, $default = null)
    {
        if ($this->has($id)) {
            // cached from has()
            $val = $this->cached_value;

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

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

    /**
     * {@inheritDoc}
     */
    public function has(/*# string */ $id)/*# : bool */
    {
        // checked already
        if ($id === $this->cached_id) {
            return null !== $this->cached_value;
        }

        // default result
        $this->cached_id = $id;
        $this->cached_value = null;

        // try get config
        try {
            $this->loadConfig((string) $id);
            $this->cached_value = $this->config->getNode((string) $id);
            return null !== $this->cached_value;
        } catch (\Exception $e) {
            $this->throwError($e->getMessage(), $e->getCode());
            return false;
        }
    }

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

            // replace the node
            $this->cached_id = null;
            $this->config->addNode($id, $value);

            return $this->has($id);
        } else {
            $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 = (int) $type;
        return $this;
    }

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

        // $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)
    {
        // load super global
        if ('' !== $group && '_' === $group[0]) {
            return $this->loadGlobal($group);
        }

        // load from config
        $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 super global unknown
     * @access protected
     */
    protected function loadGlobal(/*# string */ $group)
// Bad
class Router
{
    public function generate($path)
    {
        return $_SERVER['HOST'].$path;
    }
}

// Better
class Router
{
    private $host;

    public function __construct($host)
    {
        $this->host = $host;
    }

    public function generate($path)
    {
        return $this->host.$path;
    }
}

class Controller
{
    public function myAction(Request $request)
    {
        // Instead of
        $page = isset($_GET['page']) ? intval($_GET['page']) : 1;

        // Better (assuming you use the Symfony2 request)
        $page = $request->query->get('page', 1);
    }
}
    {
        if (!isset($GLOBALS[$group])) {
            $this->throwError(
                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
     *
     * - returns 'system' from $id 'system.dir.tmp'
     * - '.system.tmpdir' is invalid
     *
     * @param  string $id
     * @return string
     * @access protected
     */
    protected function getGroupName(/*# string */ $id)/*# : string */
    {
        return explode(
            $this->config->getDelimiter(),
            ltrim($id, $this->config->getDelimiter())
        )[0];
    }

    /**
     * Override 'referenceLookup()' in ReferenceTrait.
     *
     * Delegator support goes here
     *
     * @since 2.0.10 using recursive getDelegator
     * {@inheritDoc}
     */
    protected function referenceLookup(/*# string */ $name)
    {
        if ($this->hasDelegator()) {
            // get delegator recursively
            $delegator = $this->getDelegator(true);
            $val = $delegator->get($name);
        } else {
            $val = $this->getReference($name);
        }
        return $val;
    }

    /**
     * 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\Delegator\DelegatorAwareTrait;
31			use Phossa2\Shared\Delegator\DelegatorAwareInterface;
32
33			/**
34			* Config
35			*
36			* @package Phossa2\Config
37			* @author Hong Zhang <[email protected]>
38			* @see ObjectAbstract
39			* @see ConfigInterface
40			* @see WritableInterface
41			* @see \ArrayAccess
42			* @see ReferenceInterface
43			* @see DelegatorAwareInterface
44			* @version 2.1.0
45			* @since 2.0.0 added
46			* @since 2.0.7 changed DelegatorAware* stuff
47			* @since 2.0.10 using recursive getDelegator
48			* @since 2.0.12 changed `set()` return value
49			*/
50			class Config extends ObjectAbstract implements ConfigInterface, WritableInterface, \ArrayAccess, ReferenceInterface, DelegatorAwareInterface
51			{
52			use ReferenceTrait, DelegatorAwareTrait, ArrayAccessTrait, WritableTrait;
53
54			/**
55			* error type
56			*
57			* @var int
58			*/
59			const ERROR_IGNORE = 0;
60			const ERROR_WARNING = 1;
61			const ERROR_EXCEPTION = 2;
62
63			/**
64			* the config loader
65			*
66			* @var ConfigLoaderInterface
67			* @access protected
68			*/
69			protected $loader;
70
71			/**
72			* the config tree
73			*
74			* @var TreeInterface
75			* @access protected
76			*/
77			protected $config;
78
79			/**
80			* cache loaded group names
81			*
82			* @var array
83			* @access protected
84			*/
85			protected $loaded = [];
86
87			/**
88			* How to dealing with error, ignore/trigger_error/exception etc.
89			*
90			* @var int
91			* @access protected
92			*/
93			protected $error_type = self::ERROR_WARNING;
94
95			/**
96			* @var string
97			* @access private
98			*/
99			private $cached_id;
100
101			/**
102			* @var mixed
103			* @access private
104			*/
105			private $cached_value;
106
107			/**
108			* Constructor
109			*
110			* @param ConfigLoaderInterface $loader config loader if any
111			* @param TreeInterface $configTree config tree if any
112			* @param array $configData config data for the tree
113			* @access public
114			* @api
115			*/
116			public function __construct(
117			ConfigLoaderInterface $loader = null,
118			TreeInterface $configTree = null,
119			array $configData = []
120			) {
121			$this->loader = $loader ?: new DummyLoader();
122			$this->config = $configTree ?: new Tree($configData);
123			}
124
125			/**
126			* {@inheritDoc}
127			*/
128			public function get(/# string / $id, $default = null)
129			{
130			if ($this->has($id)) {
131			// cached from has()
132			$val = $this->cached_value;
133
134			// dereference
135			$this->deReferenceArray($val);
136
137			return null === $val ? $default : $val;
138			}
139			return $default;
140			}
141
142			/**
143			* {@inheritDoc}
144			*/
145			public function has(/# string / $id)/# : bool /
146			{
147			// checked already
148			if ($id === $this->cached_id) {
149			return null !== $this->cached_value;
150			}
151
152			// default result
153			$this->cached_id = $id;
154			$this->cached_value = null;
155
156			// try get config
157			try {
158			$this->loadConfig((string) $id);
159			$this->cached_value = $this->config->getNode((string) $id);
160			return null !== $this->cached_value;
161			} catch (\Exception $e) {
162			$this->throwError($e->getMessage(), $e->getCode());
163			return false;
164			}
165			}
166
167			/**
168			* {@inheritDoc}
169			*/
170			public function set(/# string / $id, $value)/# : bool /
171			{
172			if ($this->isWritable()) {
173			// lazy load, no dereference
174			$this->loadConfig((string) $id);
175
176			// replace the node
177			$this->cached_id = null;
178			$this->config->addNode($id, $value);
179
180			return $this->has($id);
181			} else {
182			$this->throwError(
183			Message::get(Message::CONFIG_NOT_WRITABLE),
184			Message::CONFIG_NOT_WRITABLE
185			);
186			}
187			}
188
189			/**
190			* Set error type
191			*
192			* @param int $type
193			* @return $this
194			* @access public
195			* @api
196			*/
197			public function setErrorType(/# int / $type)
198			{
199			$this->error_type = (int) $type;
200			return $this;
201			}
202
203			/**
204			* Load config
205			*
206			* @param string $id
207			* @return $this
208			* @throws LogicException if current $error_type is to throw exception
209			* @access protected
210			*/
211			protected function loadConfig(/# string / $id)
212			{
213			// get group name
214			$group = $this->getGroupName($id);
215
216			// $group loaded ?
217			if (isset($this->loaded[$group])) {
218			return $this;
219			}
220
221			// mark as loaded
222			$this->loaded[$group] = true;
223
224			// loading the group
225			return $this->loadByGroup($group);
226			}
227
228			/**
229			* Load one group config, force loading all groups if $group == ''
230			*
231			* @param string $group
232			* @return $this
233			* @throws \Exception group loading issues
234			* @access protected
235			*/
236			protected function loadByGroup(/# string / $group)
237			{
238			// load super global
239			if ('' !== $group && '_' === $group[0]) {
240			return $this->loadGlobal($group);
241			}
242
243			// load from config
244			$conf = $this->loader->load($group);
245
246			foreach ($conf as $grp => $data) {
247			$this->config->addNode($grp, $data);
248			}
249
250			return $this;
251			}
252
253			/**
254			* Load super globals
255			*
256			* @param string $group
257			* @return $this
258			* @throws LogicException if super global unknown
259			* @access protected
260			*/
261			protected function loadGlobal(/# string / $group)
			0 ignored issues – show Coding Style introduced 2016-09-27 11:59 UTC by Report Bug Copy Issue Report `loadGlobal` uses the super-global variable `$GLOBALS` which is generally not recommended. Instead of super-globals, we recommend to explicitly inject the dependencies of your class. This makes your code less dependent on global state and it becomes generally more testable: // Bad class Router { public function generate($path) { return $_SERVER['HOST'].$path; } } // Better class Router { private $host; public function __construct($host) { $this->host = $host; } public function generate($path) { return $this->host.$path; } } class Controller { public function myAction(Request $request) { // Instead of $page = isset($_GET['page']) ? intval($_GET['page']) : 1; // Better (assuming you use the Symfony2 request) $page = $request->query->get('page', 1); } } Loading history...
262			{
263			if (!isset($GLOBALS[$group])) {
264			$this->throwError(
265			Message::get(Message::CONFIG_GLOBAL_UNKNOWN, $group),
266			Message::CONFIG_GLOBAL_UNKNOWN
267			);
268			}
269
270			// load super global
271			$this->config->addNode($group, $GLOBALS[$group]);
272
273			return $this;
274			}
275
276			/**
277			* Get group name
278			*
279			* - returns 'system' from $id 'system.dir.tmp'
280			* - '.system.tmpdir' is invalid
281			*
282			* @param string $id
283			* @return string
284			* @access protected
285			*/
286			protected function getGroupName(/# string / $id)/# : string /
287			{
288			return explode(
289			$this->config->getDelimiter(),
290			ltrim($id, $this->config->getDelimiter())
291			)[0];
292			}
293
294			/**
295			* Override 'referenceLookup()' in ReferenceTrait.
296			*
297			* Delegator support goes here
298			*
299			* @since 2.0.10 using recursive getDelegator
300			* {@inheritDoc}
301			*/
302			protected function referenceLookup(/# string / $name)
303			{
304			if ($this->hasDelegator()) {
305			// get delegator recursively
306			$delegator = $this->getDelegator(true);
307			$val = $delegator->get($name);
308			} else {
309			$val = $this->getReference($name);
310			}
311			return $val;
312			}
313
314			/**
315			* throw exception if current $error_type is to throw exception
316			*
317			* {@inheritDoc}
318			*/
319			protected function resolveUnknown(/# string / $name)
320			{
321			// warn if reference unknown
322			$this->throwError(
323			Message::get(Message::CONFIG_REFERENCE_UNKNOWN, $name),
324			Message::CONFIG_REFERENCE_UNKNOWN
325			);
326
327			return null;
328			}
329
330			/**
331			* {@inheritDoc}
332			*/
333			protected function getReference(/# string / $name)
334			{
335			return $this->get($name);
336			}
337
338			/**
339			* Dealing errors
340			*
341			* @param string $message
342			* @param int $code
343			* @return $this
344			* @throws LogicException if current $error_type is to throw exception
345			* @access protected
346			*/
347			protected function throwError(/# string / $message, /# int / $code)
348			{
349			switch ($this->error_type) {
350			case self::ERROR_WARNING:
351			trigger_error($message, \E_USER_WARNING);
352			break;
353			case self::ERROR_EXCEPTION:
354			throw new LogicException($message, $code);
355			default:
356			break;
357			}
358			return $this;
359			}
360			}
361

phossa2 / libs

Config::setErrorType() A last analyzed 2016-10-12 00:59 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

Config::setErrorType() A
last analyzed 2016-10-12 00:59 UTC