Config::__construct() - Code Metrics - Inspection of "added phpstan" - logikostech/util - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Push — master ( 24e4d5...d08b25 )

by Todd

created 2017-11-16 21:09 UTC

Config::__construct() A

↳ Parent: Config

Complexity

Conditions	2
Paths	2

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	2
eloc	3
nc	2
nop	1

<?php

namespace Logikos\Util;

/**
 * This is largely inspired by \Phalcon\Config - https://docs.phalconphp.com/hr/3.2/api/Phalcon_Config
 * NOTICE: \Phalcon\Config will be much faster than this class and you are encouraged to use it
 * @see ../docs/config/README.md
 */
abstract class Config implements \ArrayAccess, \Countable, \Iterator {
  private $locked   = false;
  private $values   = [];

  public function __construct(array $arrayConfig = []) {
    foreach($arrayConfig as $key => $value)
      $this->offsetSet($key, $value);

    $this->onConstruct();
  }

  // override this if you want to
  protected function onConstruct() {}

  public function isLocked() {
    return $this->locked;
  }

  public function get($key, $default = null) {
    return $this->offsetExists($key) ? $this->offsetGet($key) : $default;
  }

  public function has($key) {
    return $this->offsetExists($key);
  }

  public function toArray() {
    $array = [];
    foreach ($this->values as $key => $value) {
      if (is_object($value) && method_exists($value, 'toArray')) {
        $array[$key] = $value->toArray();
        continue;
      }
      $array[$key] = $value;
    }
    return $array;
  }

  public function path($path, $default = null, $delimiter = '.') {
    $tokens = explode($delimiter, $path);
    $token  = array_shift($tokens);
    if ($this->get($token) instanceof self)
      return $this[$token]->path(implode('.', $tokens), $default);
    return $this->get($token, $default);
  }


  # Countable
  public function count() {
    return count($this->values);
  }


  # ArrayAccess
  public function offsetExists($offset) {
    return array_key_exists($offset, $this->values);
  }

  public function offsetGet($offset) {
    if (!$this->offsetExists($offset))
      throw new \OutOfBoundsException("offset '{$offset}' does not exist");
    return $this->values[$offset];
  }

  public function offsetSet($offset, $value) {
    $this->blockIfLocked();
    $this->values[strval($offset)] = is_array($value)
        ? new static($value)
        : $value;
  }

  public function offsetUnset($offset) {
    $this->blockIfLocked();
    unset($this->values[strval($offset)]);
  }


  # Iterator
  public function rewind()  { return reset($this->values);        }
  public function key()     { return key($this->values);          }
  public function current() { return current($this->values);      }
  public function next()    { return next($this->values);         }
  public function valid()   { return key($this->values) !== null; }


  # Magic Property Access
  public function __set($offset, $value) { $this->offsetSet($offset, $value);   }
  public function __unset($offset)       { $this->offsetUnset($offset);         }
  public function __get($offset)         { return $this->offsetGet($offset);    }
  public function __isset($offset)       { return $this->offsetExists($offset); }

  /**
   * @param array $data
   * @return static
   */
  public static function __set_state(array $data) {
    return new static($data);
  }

  public function lock() {
    $this->locked = true;
  }

  protected function rawValues() {
    return $this->values;
  }

  protected function isConfigObject($value) {
    return $value instanceof Config;
  }

  private function blockIfLocked() {
    if ($this->isLocked())
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
if ($a->getObject()) {
      throw new CanNotMutateException();
  }
}

1			<?php
2
3			namespace Logikos\Util;
4
5			/**
6			* This is largely inspired by \Phalcon\Config - https://docs.phalconphp.com/hr/3.2/api/Phalcon_Config
7			* NOTICE: \Phalcon\Config will be much faster than this class and you are encouraged to use it
8			* @see ../docs/config/README.md
9			*/
10			abstract class Config implements \ArrayAccess, \Countable, \Iterator {
11			private $locked = false;
12			private $values = [];
13
14			public function __construct(array $arrayConfig = []) {
15			foreach($arrayConfig as $key => $value)
16			$this->offsetSet($key, $value);
17
18			$this->onConstruct();
19			}
20
21			// override this if you want to
22			protected function onConstruct() {}
23
24			public function isLocked() {
25			return $this->locked;
26			}
27
28			public function get($key, $default = null) {
29			return $this->offsetExists($key) ? $this->offsetGet($key) : $default;
30			}
31
32			public function has($key) {
33			return $this->offsetExists($key);
34			}
35
36			public function toArray() {
37			$array = [];
38			foreach ($this->values as $key => $value) {
39			if (is_object($value) && method_exists($value, 'toArray')) {
40			$array[$key] = $value->toArray();
41			continue;
42			}
43			$array[$key] = $value;
44			}
45			return $array;
46			}
47
48			public function path($path, $default = null, $delimiter = '.') {
49			$tokens = explode($delimiter, $path);
50			$token = array_shift($tokens);
51			if ($this->get($token) instanceof self)
52			return $this[$token]->path(implode('.', $tokens), $default);
53			return $this->get($token, $default);
54			}
55
56
57			# Countable
58			public function count() {
59			return count($this->values);
60			}
61
62
63			# ArrayAccess
64			public function offsetExists($offset) {
65			return array_key_exists($offset, $this->values);
66			}
67
68			public function offsetGet($offset) {
69			if (!$this->offsetExists($offset))
70			throw new \OutOfBoundsException("offset '{$offset}' does not exist");
71			return $this->values[$offset];
72			}
73
74			public function offsetSet($offset, $value) {
75			$this->blockIfLocked();
76			$this->values[strval($offset)] = is_array($value)
77			? new static($value)
78			: $value;
79			}
80
81			public function offsetUnset($offset) {
82			$this->blockIfLocked();
83			unset($this->values[strval($offset)]);
84			}
85
86
87			# Iterator
88			public function rewind() { return reset($this->values); }
89			public function key() { return key($this->values); }
90			public function current() { return current($this->values); }
91			public function next() { return next($this->values); }
92			public function valid() { return key($this->values) !== null; }
93
94
95			# Magic Property Access
96			public function __set($offset, $value) { $this->offsetSet($offset, $value); }
97			public function __unset($offset) { $this->offsetUnset($offset); }
98			public function __get($offset) { return $this->offsetGet($offset); }
99			public function __isset($offset) { return $this->offsetExists($offset); }
100
101			/**
102			* @param array $data
103			* @return static
104			*/
105			public static function __set_state(array $data) {
106			return new static($data);
107			}
108
109			public function lock() {
110			$this->locked = true;
111			}
112
113			protected function rawValues() {
114			return $this->values;
115			}
116
117			protected function isConfigObject($value) {
118			return $value instanceof Config;
119			}
120
121			private function blockIfLocked() {
122			if ($this->isLocked())
			0 ignored issues – show Bug introduced 2017-11-16 20:21 UTC by Report Bug Copy Issue Report Are you sure the usage of `$this->isLocked()` targeting `Logikos\Util\Config::isLocked()` seems to always return null. This check looks for function or method calls that always return null and whose return value is used. class A { function getObject() { return null; } } $a = new A(); if ($a->getObject()) { The method `getObject()` can return nothing but null, so it makes no sense to use the return value. The reason is most likely that a function or method is imcomplete or has been reduced for debug purposes. Loading history...
123			throw new CanNotMutateException();
124			}
125			}

logikostech / util

Push — master ( 24e4d5...d08b25 )

Config::__construct() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like