Logikos\Util\Config

Complexity

Total Complexity

34

Size/Duplication

Total Lines	110
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

27 Methods

Rating	Name	Duplication	Size	Complexity
A	isConfigObject()	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	key()	0	1	1
A	__isset()	0	1	1
A	count()	0	2	1
A	next()	0	1	1
A	current()	0	1	1
A	rewind()	0	1	1
A	rawValues()	0	2	1
A	hasToArray()	0	2	2
A	lock()	0	2	1
A	get()	0	2	2
A	offsetExists()	0	2	1
A	path()	0	2	1
A	isLocked()	0	2	1
A	offsetSet()	0	5	2
A	__set()	0	1	1
A	offsetUnset()	0	3	1
A	toArray()	0	6	2
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;

use Logikos\Util\Config\PathEval;

/**
 * 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() {
    return array_map(
        function ($value) {
          return $this->hasToArray($value) ? $value->toArray() : $value;
        },
        $this->values
    );
  }

  private function hasToArray($value): bool {
    return is_object($value) && method_exists($value, 'toArray');
  }

  public function path($path, $default = null, $delimiter = '.') {
    return (new PathEval($this))->find($path, $default, $delimiter);
  }

  # 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): Config {
    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();
  }
}