Map

Complexity

Total Complexity

27

Size/Duplication

Total Lines	143
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Importance

Changes	6
Bugs	3	Features	1

11 Methods

Rating	Name	Duplication	Size	Complexity
A	all()	0	3	1
A	exists()	0	3	1
A	clear()	0	3	1
A	load()	0	3	2
A	get()	0	11	4
A	set()	0	8	2
A	delete()	0	4	2
A	merge()	0	5	2
A	compact()	0	13	3
B	find()	0	10	7
A	jsonSerialize()	0	3	1

<?php

/**
 * Map class
 *
 * The map class allow to handle a repository of key-values data.
 * Values are accessibles via a dot notation key path.
 *
 * @package core
 * @author stefano.azzolini@caffeina.com
 * @copyright Caffeina srl - 2016 - http://caffeina.com
 */

class Map implements JsonSerializable {

PSR1 recommends that each class must be in a namespace of at least one level to avoid collisions.

    protected $fields = [];

    /**
     * Returns the map as an associative array
     * @return array reference
     */
    public function & all(){
        return $this->fields;
    }

    /**
     * Get a value assigned to a key path from the map
     * @param  string $key The key path of the value in dot notation
     * @param  mixed $default (optional) The default value. If is a callable it will executed and the return value will be used.
     * @return mixed The value of the key or the default (resolved) value if the key not existed.
     */
    public function get($key, $default=null){
        if (null !== ($ptr =& $this->find($key,false))){
            return $ptr;
        } else {
            if ($default !== null){
                return $this->set($key, is_callable($default) ? call_user_func($default) : $default);
            } else {
                return null;
            }
        }
    }

    /**
     * Set a value for a key path from map
     * @param  string $key The key path of the value in dot notation
     * @param  mixed $value (optional) The value. If is a callable it will executed and the return value will be used.
     * @return mixed The value of the key or the default (resolved) value if the key not existed.
     */
    public function set($key, $value=null){
        if (is_array($key)) {
            return $this->merge($key);
        } else {
            $ptr =& $this->find($key, true);
            return $ptr = $value;
        }
    }

    /**
     * Delete a value and the key path from map.
     * @param  string $key The key path in dot notation
     * @param  boolean $compact (optional) Compact map removing empty paths.
     */
    public function delete($key, $compact=true){
        $this->set($key, null);
        if ($compact) $this->compact();
    }

    /**
     * Check if a key path exists in map.
     * @param  string $key The key path in dot notation
     * @return boolean
     */
    public function exists($key){
        return null !== $this->find($key, false);
    }

    /**
     * Clear all key path in map.
     */
    public function clear(){
        $this->fields = [];
    }

    public function __construct($fields=null){
        $this->load($fields);
    }

    /**
     * Load an associative array/object as the map source.
     * @param  string $fields The array to merge
     */
    public function load($fields){
        if ($fields) $this->fields = (array)$fields;
    }

    /**
     * Merge an associative array to the map.
     * @param  array   $array The array to merge
     * @param  boolean $merge_back If `true` merge the map over the $array, if `false` (default) the reverse.
     */
    public function merge($array, $merge_back=false){
        $this->fields = $merge_back
            ? array_replace_recursive((array)$array, $this->fields)
            : array_replace_recursive($this->fields, (array)$array);
    }

    /**
     * Compact map removing empty paths
     */

    public function compact(){

        $array_filter_rec = function($input, $callback = null) use (&$array_filter_rec) {
            foreach ($input as &$value) {
                if (is_array($value)) {
                    $value = $array_filter_rec($value, $callback);
                }
            }
            return array_filter($input, $callback);
        };

        $this->fields = $array_filter_rec($this->fields,function($a){ return $a !== null; });
    }

    /**
     * Navigate map and find the element from the path in dot notation.
     * @param  string  $path Key path in dot notation.
     * @param  boolean $create If true will create empty paths.
     * @param  callable  If passed this callback will be applied to the founded value.
     * @return mixed The founded value.
     */
    public function & find($path, $create=false, callable $operation=null) {
        $create ? $value =& $this->fields : $value = $this->fields;
        foreach (explode('.',$path) as $tok) if ($create || isset($value[$tok])) {
          $value =& $value[$tok];
        } else {
          $value = $create ? $value :  null;  break;
        }
        if ( is_callable($operation) ) $operation($value);
        return $value;
    }

    /**
     * JsonSerializable Interface handler
     *
     * @method jsonSerialize
     *
     * @return string        The json object
     */
    public function jsonSerialize(){
      return $this->fields;
    }


}