HelperArray

Complexity

Total Complexity

34

Size/Duplication

Total Lines	234
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Test Coverage

Coverage

67.61%

Importance

Changes	11
Bugs	0	Features	0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	stringToArray()	0	3	3
A	makeArrayRef()	0	5	2
A	makeArray()	0	5	1
B	filter()	0	15	5
B	map()	0	38	4
A	filterEmpty()	0	3	1
A	stringToArrayFilterEmpty()	0	3	1
A	merge()	0	14	2
A	keyExistsOr()	0	3	2
B	cloneDeep()	0	13	6
B	array_repack()	0	17	7

<?php

class HelperArray {

  /**
   * Overwrites old array with new
   */
  const MERGE_OVERWRITE = 0;
  /**
   * Merges old array with new with array_merge()
   * String keys replaced, numeric keys renumbered
   */
  const MERGE_PHP = 1;


  /**
   * No array cloning - just stay with same objects
   */
  const CLONE_ARRAY_NONE = 0;
  /**
   * Clone objects on first level of array
   */
  const CLONE_ARRAY_SHALLOW = 1;
  /**
   * Clone objects recursive on any array level
   */
  const CLONE_ARRAY_RECURSIVE = 2;

  /**
   * Convert $delimiter delimited string to array
   *
   * @param mixed  $string
   * @param string $delimiter
   *
   * @return array
   */
  public static function stringToArray($string, $delimiter = ',') {
    return is_string($string) && !empty($string) ? explode($delimiter, $string) : array();
  }

  /**
   * Convert single value to array by reference
   *
   * @param mixed &$value
   */
  public static function makeArrayRef(&$value, $index = 0) {
    if (!is_array($value)) {
      $value = array($index => $value);
    }
  }


  /**
   * Convert single value to array
   *
   * @param mixed $value
   *
   * @return array
   */
  public static function makeArray($value, $index = 0) {
    static::makeArrayRef($value, $index);

    return $value;
  }

  /**
   * Filters array by callback
   *
   * @param mixed    $array
   * @param callable $callback
   *
   * @return array
   */
  public static function filter(&$array, $callback) {
    $result = array();

    if (is_array($array) && !empty($array)) {
//      $result = array_filter($array, $callback);

54% of this comment could be valid code. Did you maybe forget this after debugging?

      foreach ($array as $value) {
        if (call_user_func($callback, $value)) {
          $result[] = $value;
          // TODO - array_filter
        }
      }
    }

    return $result;
  }

  /**
   * Filters array by callback
   *
   * @param mixed    $array
   * @param callable $callback
   * @param bool     $withKeys
   *
   * @return array
   */
  public static function map(&$array, $callback, $withKeys = false) {
    $result = array();

//    var_dump('entering map');

60% of this comment could be valid code. Did you maybe forget this after debugging?

//    var_dump('$withKeys');
//    var_dump($withKeys);

    if (is_array($array) && !empty($array)) {


      if ($withKeys) {
        $result = array_map($callback, $array, array_keys($array));
      } else {
        $result = array_map($callback, $array);
      }

//      $result = $withKeys

52% of this comment could be valid code. Did you maybe forget this after debugging?

//        ? array_map($callback, $array)
//        : array_map($callback, $array, array_keys($array))
//      ;

//      var_dump($array);

57% of this comment could be valid code. Did you maybe forget this after debugging?

//      if ($withKeys) {
//        var_dump('$array');
//        var_dump($array);
////        var_dump(array_keys($array));
//        die();
//      }

//      foreach ($array as $key => $value) {

55% of this comment could be valid code. Did you maybe forget this after debugging?

//        if (call_user_func($callback, $value)) {
//          $result[$key] = $value;
//        }
//      }
    }

    return $result;
  }

  /**
   * Filter empty() values from array
   *
   * @param $array
   *
   * @return array
   */
  public static function filterEmpty($array) {
    return static::filter($array, 'Validators::isNotEmpty');
  }

  /**
   * @param string $string
   * @param string $delimiter
   *
   * @return array
   */
  public static function stringToArrayFilterEmpty($string, $delimiter = ',') {
    return static::filterEmpty(static::stringToArray($string, $delimiter));
  }

  /**
   * @param mixed|array &$arrayOld
   * @param mixed|array $arrayNew
   * @param int         $mergeStrategy - default is HelperArray::MERGE_OVERWRITE
   */
  public static function merge(&$arrayOld, $arrayNew = array(), $mergeStrategy = HelperArray::MERGE_OVERWRITE) {
    static::makeArrayRef($arrayNew);
    static::makeArrayRef($arrayOld);

    switch ($mergeStrategy) {
      case HelperArray::MERGE_PHP:
        $arrayOld = array_merge($arrayOld, $arrayNew);
      break;

      default:
        $arrayOld = $arrayNew;
      break;
    }
  }

  /**
   * Checks if key exists in array. If yes - return value on key otherwise return default value
   *
   * @param array &$array
   * @param mixed $key
   * @param mixed $default
   *
   * @return mixed
   */
  public static function keyExistsOr(&$array, $key, $default) {
    return array_key_exists($key, $array) ? $array[$key] : $default;
  }

  /**
   * Clone objects in array
   *
   * @param array &$array - Any dimensional array with presumed objects in there
   * @param int   $deep - HelperArray::CLONE_ARRAY_xxx constants
   */
  public static function cloneDeep(&$array, $deep = HelperArray::CLONE_ARRAY_RECURSIVE) {
    if ($deep == HelperArray::CLONE_ARRAY_NONE) {
      return;
    }

    foreach ($array as &$value) {
      if (is_object($value)) {
        $value = clone $value;
      } elseif (is_array($value) && $deep == HelperArray::CLONE_ARRAY_RECURSIVE) {
        static::cloneDeep($value, $deep);
      }
    }
  }

  /**
   * Repacking array to provided level, removing null elements
   *
   * @param array &$array
   * @param int   $level
   */
  public static function array_repack(&$array, $level = 0) {
    // TODO $lock_table не нужна тут
    if (!is_array($array)) {
      return;
    }

    foreach ($array as $key => &$value) {
      if ($value === null) {
        unset($array[$key]);
      } elseif ($level > 0 && is_array($value)) {
        static::array_repack($value, $level - 1);
        if (empty($value)) {
          unset($array[$key]);
        }
      }
    }
  }

}