Logikos\Util\Config

Complexity

Total Complexity

35

Size/Duplication

Total Lines	114
Duplicated Lines	0 %

Importance

Changes

0

26 Methods

Rating	Name	Duplication	Size	Complexity
A	isConfigObject()	0	2	1
A	rawValues()	0	2	1
A	valid()	0	1	1
A	__get()	0	1	1
A	blockIfLocked()	0	3	2
A	__set_state()	0	2	1
A	lock()	0	2	1
A	key()	0	1	1
A	get()	0	2	2
A	offsetExists()	0	2	1
A	__isset()	0	1	1
A	count()	0	2	1
A	path()	0	6	2
A	isLocked()	0	2	1
A	offsetSet()	0	5	2
A	__set()	0	1	1
A	next()	0	1	1
A	current()	0	1	1
A	rewind()	0	1	1
A	offsetUnset()	0	3	1
A	toArray()	0	10	4
A	has()	0	2	1
A	__unset()	0	1	1
A	onConstruct()	0	1	1
A	offsetGet()	0	4	2
A	__construct()	0	5	2

<?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())

Are you sure the usage of $this->isLocked() targeting Logikos\Util\Config::isLocked() seems to always return null.

      throw new CanNotMutateException();
  }
}