eventespresso / event-espresso-core

core/services/database/OptionEngine.php

Indentation +60 added lines, -60 removed lines

@@ -13,75 +13,75 @@
 class OptionEngine
 {
 
-    /**
-     * @var   bool
-     */
-    private $is_network_option;
+	/**
+	 * @var   bool
+	 */
+	private $is_network_option;
 
-    /**
-     * @var   int
-     */
-    private $network_ID;
+	/**
+	 * @var   int
+	 */
+	private $network_ID;
 
 
-    /**
-     * @param bool $is_network_option
-     */
-    public function __construct(bool $is_network_option = false)
-    {
-        $this->is_network_option = $is_network_option;
-        $this->network_ID        = get_current_network_id();
-    }
+	/**
+	 * @param bool $is_network_option
+	 */
+	public function __construct(bool $is_network_option = false)
+	{
+		$this->is_network_option = $is_network_option;
+		$this->network_ID        = get_current_network_id();
+	}
 
 
-    /**
-     * @param string $option_name
-     * @param mixed  $default_value
-     * @return false|mixed|void
-     */
-    public function getOption(string $option_name, $default_value)
-    {
-        return $this->is_network_option
-            ? get_network_option($this->network_ID, $option_name, $default_value)
-            : get_option($option_name, $default_value);
-    }
+	/**
+	 * @param string $option_name
+	 * @param mixed  $default_value
+	 * @return false|mixed|void
+	 */
+	public function getOption(string $option_name, $default_value)
+	{
+		return $this->is_network_option
+			? get_network_option($this->network_ID, $option_name, $default_value)
+			: get_option($option_name, $default_value);
+	}
 
 
-    /**
-     * @param string $option_name
-     * @param mixed  $value
-     * @param string $autoload
-     * @return bool
-     */
-    public function addOption(string $option_name, $value, string $autoload): bool
-    {
-        return $this->is_network_option
-            ? add_network_option($this->network_ID, $option_name, $value)
-            : add_option($option_name, $value, '', $autoload);
-    }
+	/**
+	 * @param string $option_name
+	 * @param mixed  $value
+	 * @param string $autoload
+	 * @return bool
+	 */
+	public function addOption(string $option_name, $value, string $autoload): bool
+	{
+		return $this->is_network_option
+			? add_network_option($this->network_ID, $option_name, $value)
+			: add_option($option_name, $value, '', $autoload);
+	}
 
 
-    /**
-     * @param string $option_name
-     * @param mixed  $value
-     * @return bool
-     */
-    public function updateOption(string $option_name, $value): bool
-    {
-        return $this->is_network_option
-            ? update_network_option($this->network_ID, $option_name, $value)
-            : update_option($option_name, $value);
-    }
+	/**
+	 * @param string $option_name
+	 * @param mixed  $value
+	 * @return bool
+	 */
+	public function updateOption(string $option_name, $value): bool
+	{
+		return $this->is_network_option
+			? update_network_option($this->network_ID, $option_name, $value)
+			: update_option($option_name, $value);
+	}
 
 
-    /**
-     * @param string $option_name
-     * @return bool
-     */
-    public function deleteOption(string $option_name): bool
-    {
-        return $this->is_network_option
-            ? delete_network_option($this->network_ID, $option_name)
-            : delete_option($option_name);
-    }
+	/**
+	 * @param string $option_name
+	 * @return bool
+	 */
+	public function deleteOption(string $option_name): bool
+	{
+		return $this->is_network_option
+			? delete_network_option($this->network_ID, $option_name)
+			: delete_option($option_name);
+	}
 }

core/services/database/WordPressOption.php

Indentation +177 added lines, -177 removed lines

@@ -17,181 +17,181 @@
  */
 abstract class WordPressOption
 {
-    const NOT_SET_YET = 'wordpress-option-value-not-yet-set';
-
-    /**
-     * WordPress makes it difficult to determine if an option successfully saved or not,
-     * which is sometimes really important to know, especially if the information you are saving is critical.
-     * The following options allow us to have a better chance of knowing when an update actually failed
-     * or when everything is OK but it just didn't update because the value hasn't changed.
-     */
-    const UPDATE_SUCCESS = 1;
-
-    const UPDATE_NONE    = 0;
-
-    const UPDATE_ERROR   = -1;
-
-    /**
-     * @var boolean
-     */
-    private $autoload = false;
-
-    /**
-     * @var mixed
-     */
-    private $default_value = null;
-
-    /**
-     * @var string
-     */
-    private $option_name = '';
-
-    /**
-     * @var mixed
-     */
-    private $value = WordPressOption::NOT_SET_YET;
-
-    /**
-     * @var OptionEngine
-     */
-    private $option_engine;
-
-
-    /**
-     * WordPressOption constructor.
-     *
-     * @param string $option_name
-     * @param mixed  $default_value
-     * @param bool   $autoload				if true, will load the option on EVERY request
-     * @param bool 	 $is_network_option		if true, will save the option to the network as opposed to the current blog
-     */
-    public function __construct(
-        string $option_name,
-        $default_value,
-        bool $autoload = false,
-        bool $is_network_option = false
-    ) {
-        $this->setAutoload($autoload);
-        $this->setDefaultValue($default_value);
-        $this->setOptionName($option_name);
-        $this->option_engine = new OptionEngine($is_network_option);
-    }
-
-
-    /**
-     * @param bool|string $autoload
-     */
-    public function setAutoload($autoload): void
-    {
-        $this->autoload = filter_var($autoload, FILTER_VALIDATE_BOOLEAN);
-    }
-
-
-    /**
-     * @param mixed $default_value
-     */
-    public function setDefaultValue($default_value): void
-    {
-        $this->default_value = $default_value;
-    }
-
-
-    /**
-     * @param string $option_name
-     */
-    public function setOptionName(string $option_name): void
-    {
-        $this->option_name = sanitize_key($option_name);
-    }
-
-
-    /**
-     * @return string
-     */
-    public function optionExists(): string
-    {
-        return $this->option_engine->getOption(
-            $this->option_name,
-            WordPressOption::NOT_SET_YET
-        ) !== WordPressOption::NOT_SET_YET;
-    }
-
-
-    /**
-     * @return string
-     */
-    public function getOptionName(): string
-    {
-        return $this->option_name;
-    }
-
-
-    /**
-     * @return false|mixed|void
-     */
-    public function loadOption()
-    {
-        if ($this->value === WordPressOption::NOT_SET_YET) {
-            $this->value = $this->option_engine->getOption($this->option_name, $this->default_value);
-        }
-        return $this->value;
-    }
-
-
-    /**
-     * @param $value
-     * @return int
-     */
-    public function updateOption($value): int
-    {
-        // don't update if value has not changed since last update
-        if ($this->valueIsUnchanged($value)) {
-            return WordPressOption::UPDATE_NONE;
-        }
-        $this->value = $value;
-        // because the options for updating differ when adding an option for the first time
-        // we use the WordPressOption::NOT_SET_YET to determine if things already exist in the db
-        $updated = $this->optionExists()
-            ? $this->option_engine->updateOption($this->option_name, $this->value)
-            : $this->option_engine->addOption($this->option_name, $this->value, $this->autoload());
-
-        if ($updated) {
-            return WordPressOption::UPDATE_SUCCESS;
-        }
-        return WordPressOption::UPDATE_ERROR;
-    }
-
-
-    private function valueIsUnchanged($value): bool
-    {
-        if (is_array($value) && is_array($this->value)) {
-            $diff = EEH_Array::array_diff_recursive($value, $this->value);
-            // $diff = array_diff($value, $this->value);
-            return empty($diff);
-        }
-        // emulate WP's method for checking equality
-        return $value === $this->value && maybe_serialize($value) === maybe_serialize($this->value);
-    }
-
-
-    /**
-     * @return string
-     */
-    private function autoload(): string
-    {
-        return $this->autoload ? 'yes' : 'no';
-    }
-
-
-    /**
-     * Deletes the option from the database
-     * for the rest of the request
-     *
-     * @return bool
-     * @since  $VID:$
-     */
-    public function deleteOption(): bool
-    {
-        return $this->option_engine->deleteOption($this->option_name);
-    }
+	const NOT_SET_YET = 'wordpress-option-value-not-yet-set';
+
+	/**
+	 * WordPress makes it difficult to determine if an option successfully saved or not,
+	 * which is sometimes really important to know, especially if the information you are saving is critical.
+	 * The following options allow us to have a better chance of knowing when an update actually failed
+	 * or when everything is OK but it just didn't update because the value hasn't changed.
+	 */
+	const UPDATE_SUCCESS = 1;
+
+	const UPDATE_NONE    = 0;
+
+	const UPDATE_ERROR   = -1;
+
+	/**
+	 * @var boolean
+	 */
+	private $autoload = false;
+
+	/**
+	 * @var mixed
+	 */
+	private $default_value = null;
+
+	/**
+	 * @var string
+	 */
+	private $option_name = '';
+
+	/**
+	 * @var mixed
+	 */
+	private $value = WordPressOption::NOT_SET_YET;
+
+	/**
+	 * @var OptionEngine
+	 */
+	private $option_engine;
+
+
+	/**
+	 * WordPressOption constructor.
+	 *
+	 * @param string $option_name
+	 * @param mixed  $default_value
+	 * @param bool   $autoload				if true, will load the option on EVERY request
+	 * @param bool 	 $is_network_option		if true, will save the option to the network as opposed to the current blog
+	 */
+	public function __construct(
+		string $option_name,
+		$default_value,
+		bool $autoload = false,
+		bool $is_network_option = false
+	) {
+		$this->setAutoload($autoload);
+		$this->setDefaultValue($default_value);
+		$this->setOptionName($option_name);
+		$this->option_engine = new OptionEngine($is_network_option);
+	}
+
+
+	/**
+	 * @param bool|string $autoload
+	 */
+	public function setAutoload($autoload): void
+	{
+		$this->autoload = filter_var($autoload, FILTER_VALIDATE_BOOLEAN);
+	}
+
+
+	/**
+	 * @param mixed $default_value
+	 */
+	public function setDefaultValue($default_value): void
+	{
+		$this->default_value = $default_value;
+	}
+
+
+	/**
+	 * @param string $option_name
+	 */
+	public function setOptionName(string $option_name): void
+	{
+		$this->option_name = sanitize_key($option_name);
+	}
+
+
+	/**
+	 * @return string
+	 */
+	public function optionExists(): string
+	{
+		return $this->option_engine->getOption(
+			$this->option_name,
+			WordPressOption::NOT_SET_YET
+		) !== WordPressOption::NOT_SET_YET;
+	}
+
+
+	/**
+	 * @return string
+	 */
+	public function getOptionName(): string
+	{
+		return $this->option_name;
+	}
+
+
+	/**
+	 * @return false|mixed|void
+	 */
+	public function loadOption()
+	{
+		if ($this->value === WordPressOption::NOT_SET_YET) {
+			$this->value = $this->option_engine->getOption($this->option_name, $this->default_value);
+		}
+		return $this->value;
+	}
+
+
+	/**
+	 * @param $value
+	 * @return int
+	 */
+	public function updateOption($value): int
+	{
+		// don't update if value has not changed since last update
+		if ($this->valueIsUnchanged($value)) {
+			return WordPressOption::UPDATE_NONE;
+		}
+		$this->value = $value;
+		// because the options for updating differ when adding an option for the first time
+		// we use the WordPressOption::NOT_SET_YET to determine if things already exist in the db
+		$updated = $this->optionExists()
+			? $this->option_engine->updateOption($this->option_name, $this->value)
+			: $this->option_engine->addOption($this->option_name, $this->value, $this->autoload());
+
+		if ($updated) {
+			return WordPressOption::UPDATE_SUCCESS;
+		}
+		return WordPressOption::UPDATE_ERROR;
+	}
+
+
+	private function valueIsUnchanged($value): bool
+	{
+		if (is_array($value) && is_array($this->value)) {
+			$diff = EEH_Array::array_diff_recursive($value, $this->value);
+			// $diff = array_diff($value, $this->value);
+			return empty($diff);
+		}
+		// emulate WP's method for checking equality
+		return $value === $this->value && maybe_serialize($value) === maybe_serialize($this->value);
+	}
+
+
+	/**
+	 * @return string
+	 */
+	private function autoload(): string
+	{
+		return $this->autoload ? 'yes' : 'no';
+	}
+
+
+	/**
+	 * Deletes the option from the database
+	 * for the rest of the request
+	 *
+	 * @return bool
+	 * @since  $VID:$
+	 */
+	public function deleteOption(): bool
+	{
+		return $this->option_engine->deleteOption($this->option_name);
+	}
 }

core/helpers/EEH_Array.helper.php

Indentation +201 added lines, -201 removed lines

@@ -11,221 +11,221 @@ 
  */
 class EEH_Array extends EEH_Base
 {
-    /**
-     * This method basically works the same as the PHP core function array_diff except it allows you to compare arrays
-     * of EE_Base_Class objects NOTE: This will ONLY work on an array of EE_Base_Class objects
-     *
-     * @uses array_udiff core php function for setting up our own array comparison
-     * @uses self::_compare_objects as the custom method for array_udiff
-     * @param  array $array1 an array of objects
-     * @param  array $array2 an array of objects
-     * @return array         an array of objects found in array 1 that aren't found in array 2.
-     */
-    public static function object_array_diff($array1, $array2)
-    {
-        return array_udiff($array1, $array2, array('self', '_compare_objects'));
-    }
+	/**
+	 * This method basically works the same as the PHP core function array_diff except it allows you to compare arrays
+	 * of EE_Base_Class objects NOTE: This will ONLY work on an array of EE_Base_Class objects
+	 *
+	 * @uses array_udiff core php function for setting up our own array comparison
+	 * @uses self::_compare_objects as the custom method for array_udiff
+	 * @param  array $array1 an array of objects
+	 * @param  array $array2 an array of objects
+	 * @return array         an array of objects found in array 1 that aren't found in array 2.
+	 */
+	public static function object_array_diff($array1, $array2)
+	{
+		return array_udiff($array1, $array2, array('self', '_compare_objects'));
+	}
 
-    /**
-     * Given that $arr is an array, determines if it's associative or numerically AND sequentially indexed
-     *
-     * @param array $array
-     * @return boolean
-     */
-    public static function is_associative_array(array $array): bool
-    {
-        return ! empty($array) && array_keys($array) !== range(0, count($array) - 1);
-    }
+	/**
+	 * Given that $arr is an array, determines if it's associative or numerically AND sequentially indexed
+	 *
+	 * @param array $array
+	 * @return boolean
+	 */
+	public static function is_associative_array(array $array): bool
+	{
+		return ! empty($array) && array_keys($array) !== range(0, count($array) - 1);
+	}
 
-    /**
-     * Gets an item from the array and leave the array intact. Use in place of end()
-     * when you don't want to change the array
-     *
-     * @param array $arr
-     * @return mixed what ever is in the array
-     */
-    public static function get_one_item_from_array($arr)
-    {
-        $item = end($arr);
-        reset($arr);
-        return $item;
-    }
+	/**
+	 * Gets an item from the array and leave the array intact. Use in place of end()
+	 * when you don't want to change the array
+	 *
+	 * @param array $arr
+	 * @return mixed what ever is in the array
+	 */
+	public static function get_one_item_from_array($arr)
+	{
+		$item = end($arr);
+		reset($arr);
+		return $item;
+	}
 
-    /**
-     * Detects if this is a multi-dimensional array
-     * meaning that at least one top-level value is an array. Eg [ [], ...]
-     *
-     * @param mixed $arr
-     * @return boolean
-     */
-    public static function is_multi_dimensional_array($arr)
-    {
-        if (is_array($arr)) {
-            foreach ($arr as $item) {
-                if (is_array($item)) {
-                    return true; // yep, there's at least 2 levels to this array
-                }
-            }
-        }
-        return false; // there's only 1 level, or it's not an array at all!
-    }
+	/**
+	 * Detects if this is a multi-dimensional array
+	 * meaning that at least one top-level value is an array. Eg [ [], ...]
+	 *
+	 * @param mixed $arr
+	 * @return boolean
+	 */
+	public static function is_multi_dimensional_array($arr)
+	{
+		if (is_array($arr)) {
+			foreach ($arr as $item) {
+				if (is_array($item)) {
+					return true; // yep, there's at least 2 levels to this array
+				}
+			}
+		}
+		return false; // there's only 1 level, or it's not an array at all!
+	}
 
-    /**
-     * Shorthand for isset( $arr[ $index ] ) ? $arr[ $index ] : $default
-     *
-     * @param array $arr
-     * @param mixed $index
-     * @param mixed $default
-     * @return mixed
-     */
-    public static function is_set($arr, $index, $default)
-    {
-        return isset($arr[ $index ]) ? $arr[ $index ] : $default;
-    }
+	/**
+	 * Shorthand for isset( $arr[ $index ] ) ? $arr[ $index ] : $default
+	 *
+	 * @param array $arr
+	 * @param mixed $index
+	 * @param mixed $default
+	 * @return mixed
+	 */
+	public static function is_set($arr, $index, $default)
+	{
+		return isset($arr[ $index ]) ? $arr[ $index ] : $default;
+	}
 
-    /**
-     * Exactly like `maybe_unserialize`, but also accounts for a WP bug: http://core.trac.wordpress.org/ticket/26118
-     *
-     * @param mixed $value usually a string, but could be an array or object
-     * @return mixed the UN-serialized data
-     */
-    public static function maybe_unserialize($value)
-    {
-        $data = maybe_unserialize($value);
-        // it's possible that this still has serialized data if it's the session.
-        //  WP has a bug, http://core.trac.wordpress.org/ticket/26118 that doesn't unserialize this automatically.
-        $token = 'C';
-        $data = is_string($data) ? trim($data) : $data;
-        if (is_string($data) && strlen($data) > 1 && $data[0] == $token && preg_match("/^{$token}:[0-9]+:/s", $data)) {
-            return unserialize($data);
-        } else {
-            return $data;
-        }
-    }
+	/**
+	 * Exactly like `maybe_unserialize`, but also accounts for a WP bug: http://core.trac.wordpress.org/ticket/26118
+	 *
+	 * @param mixed $value usually a string, but could be an array or object
+	 * @return mixed the UN-serialized data
+	 */
+	public static function maybe_unserialize($value)
+	{
+		$data = maybe_unserialize($value);
+		// it's possible that this still has serialized data if it's the session.
+		//  WP has a bug, http://core.trac.wordpress.org/ticket/26118 that doesn't unserialize this automatically.
+		$token = 'C';
+		$data = is_string($data) ? trim($data) : $data;
+		if (is_string($data) && strlen($data) > 1 && $data[0] == $token && preg_match("/^{$token}:[0-9]+:/s", $data)) {
+			return unserialize($data);
+		} else {
+			return $data;
+		}
+	}
 
 
-    /**
-     * insert_into_array
-     *
-     * @param array        $target_array the array to insert new data into
-     * @param array        $array_to_insert the new data to be inserted
-     * @param int|string|null $offset a known key within $target_array where new data will be inserted
-     * @param bool         $add_before whether to add new data before or after the offset key
-     * @param bool         $preserve_keys whether or not to reset numerically indexed arrays
-     * @return array
-     */
-    public static function insert_into_array(
-        array $target_array = array(),
-        array $array_to_insert = array(),
-        $offset = null,
-        bool $add_before = true,
-        bool $preserve_keys = true
-    ) {
-        $target_array_keys = array_keys($target_array);
-        // if no offset key was supplied
-        if (empty($offset)) {
-            // use start or end of $target_array based on whether we are adding before or not
-            $offset = $add_before ? 0 : count($target_array);
-        }
-        // if offset key is a string, then find the corresponding numeric location for that element
-        $offset = is_int($offset) ? $offset : array_search($offset, $target_array_keys, true);
-        // add one to the offset if adding after
-        $offset = $add_before ? $offset : $offset + 1;
-        // but ensure offset does not exceed the length of the array
-        $offset = $offset > count($target_array) ? count($target_array) : $offset;
-        // reindex array ???
-        if ($preserve_keys) {
-            // take a slice of the target array from the beginning till the offset,
-            // then add the new data
-            // then add another slice that starts at the offset and goes till the end
-            return array_slice($target_array, 0, $offset, true) + $array_to_insert + array_slice(
-                $target_array,
-                $offset,
-                null,
-                true
-            );
-        } else {
-            // since we don't want to preserve keys, we can use array_splice
-            array_splice($target_array, $offset, 0, $array_to_insert);
-            return $target_array;
-        }
-    }
+	/**
+	 * insert_into_array
+	 *
+	 * @param array        $target_array the array to insert new data into
+	 * @param array        $array_to_insert the new data to be inserted
+	 * @param int|string|null $offset a known key within $target_array where new data will be inserted
+	 * @param bool         $add_before whether to add new data before or after the offset key
+	 * @param bool         $preserve_keys whether or not to reset numerically indexed arrays
+	 * @return array
+	 */
+	public static function insert_into_array(
+		array $target_array = array(),
+		array $array_to_insert = array(),
+		$offset = null,
+		bool $add_before = true,
+		bool $preserve_keys = true
+	) {
+		$target_array_keys = array_keys($target_array);
+		// if no offset key was supplied
+		if (empty($offset)) {
+			// use start or end of $target_array based on whether we are adding before or not
+			$offset = $add_before ? 0 : count($target_array);
+		}
+		// if offset key is a string, then find the corresponding numeric location for that element
+		$offset = is_int($offset) ? $offset : array_search($offset, $target_array_keys, true);
+		// add one to the offset if adding after
+		$offset = $add_before ? $offset : $offset + 1;
+		// but ensure offset does not exceed the length of the array
+		$offset = $offset > count($target_array) ? count($target_array) : $offset;
+		// reindex array ???
+		if ($preserve_keys) {
+			// take a slice of the target array from the beginning till the offset,
+			// then add the new data
+			// then add another slice that starts at the offset and goes till the end
+			return array_slice($target_array, 0, $offset, true) + $array_to_insert + array_slice(
+				$target_array,
+				$offset,
+				null,
+				true
+			);
+		} else {
+			// since we don't want to preserve keys, we can use array_splice
+			array_splice($target_array, $offset, 0, $array_to_insert);
+			return $target_array;
+		}
+	}
 
 
-    /**
-     * array_merge() is slow and should never be used while looping over data
-     * if you don't need to preserve keys from all arrays, then using a foreach loop is much faster
-     * so really this acts more like array_replace( $array1, $array2 )
-     * or a union with the arrays flipped ( $array2 + $array1 )
-     * this saves a few lines of code and improves readability
-     *
-     * @param array $array1
-     * @param array $array2
-     * @return array
-     */
-    public static function merge_arrays_and_overwrite_keys(array $array1, array $array2)
-    {
-        foreach ($array2 as $key => $value) {
-            $array1[ $key ] = $value;
-        }
-        return $array1;
-    }
+	/**
+	 * array_merge() is slow and should never be used while looping over data
+	 * if you don't need to preserve keys from all arrays, then using a foreach loop is much faster
+	 * so really this acts more like array_replace( $array1, $array2 )
+	 * or a union with the arrays flipped ( $array2 + $array1 )
+	 * this saves a few lines of code and improves readability
+	 *
+	 * @param array $array1
+	 * @param array $array2
+	 * @return array
+	 */
+	public static function merge_arrays_and_overwrite_keys(array $array1, array $array2)
+	{
+		foreach ($array2 as $key => $value) {
+			$array1[ $key ] = $value;
+		}
+		return $array1;
+	}
 
 
-    /**
-     * given a flat array like $array = array('A', 'B', 'C')
-     * will convert into a multidimensional array like $array[A][B][C]
-     * if $final_value is provided and is anything other than null,
-     * then that will be set as the value for the innermost array key
-     * like so: $array[A][B][C] = $final_value
-     *
-     * @param array $flat_array
-     * @param mixed $final_value
-     * @return array
-     */
-    public static function convert_array_values_to_keys(array $flat_array, $final_value = null)
-    {
-        $multidimensional = array();
-        $reference = &$multidimensional;
-        foreach ($flat_array as $key) {
-            $reference[ $key ] = array();
-            $reference = &$reference[ $key ];
-        }
-        if ($final_value !== null) {
-            $reference = $final_value;
-        }
-        return $multidimensional;
-    }
+	/**
+	 * given a flat array like $array = array('A', 'B', 'C')
+	 * will convert into a multidimensional array like $array[A][B][C]
+	 * if $final_value is provided and is anything other than null,
+	 * then that will be set as the value for the innermost array key
+	 * like so: $array[A][B][C] = $final_value
+	 *
+	 * @param array $flat_array
+	 * @param mixed $final_value
+	 * @return array
+	 */
+	public static function convert_array_values_to_keys(array $flat_array, $final_value = null)
+	{
+		$multidimensional = array();
+		$reference = &$multidimensional;
+		foreach ($flat_array as $key) {
+			$reference[ $key ] = array();
+			$reference = &$reference[ $key ];
+		}
+		if ($final_value !== null) {
+			$reference = $final_value;
+		}
+		return $multidimensional;
+	}
 
 
-    /**
-     * @see http://stackoverflow.com/questions/173400/how-to-check-if-php-array-is-associative-or-sequential
-     * @param array $array
-     * @return bool
-     */
-    public static function is_array_numerically_and_sequentially_indexed(array $array)
-    {
-        return empty($array) || array_keys($array) === range(0, count($array) - 1);
-    }
+	/**
+	 * @see http://stackoverflow.com/questions/173400/how-to-check-if-php-array-is-associative-or-sequential
+	 * @param array $array
+	 * @return bool
+	 */
+	public static function is_array_numerically_and_sequentially_indexed(array $array)
+	{
+		return empty($array) || array_keys($array) === range(0, count($array) - 1);
+	}
 
 
-    /**
-     * recursively walks through an array and adds slashes to all no array elements
-     *
-     * @param mixed $element
-     * @return array|string
-     * @since   4.10.29.p
-     */
-    public static function addSlashesRecursively($element)
-    {
-        if (is_array($element)) {
-            foreach ($element as $key => $value) {
-                $element[ $key ] = EEH_Array::addSlashesRecursively($value);
-            }
-            return $element;
-        }
-        return is_string($element) ? addslashes($element) : $element;
-    }
+	/**
+	 * recursively walks through an array and adds slashes to all no array elements
+	 *
+	 * @param mixed $element
+	 * @return array|string
+	 * @since   4.10.29.p
+	 */
+	public static function addSlashesRecursively($element)
+	{
+		if (is_array($element)) {
+			foreach ($element as $key => $value) {
+				$element[ $key ] = EEH_Array::addSlashesRecursively($value);
+			}
+			return $element;
+		}
+		return is_string($element) ? addslashes($element) : $element;
+	}
 
 
 	/**
@@ -294,7 +294,7 @@ 
 	 *	print_r( EEH_Array::flattenArray($example, true) );
 	 *
 	 * 	"a:A, b:B, c:[ d:D, e:E, f:[ G, H, I ] ], [ J, K ], L, M, n:[ o:P ]"
- 	 *
+	 *
 	 * @param array $array		the array to be flattened
 	 * @param bool  $to_string	[true] will flatten the entire array down into a string
 	 *                         	[false] will only flatten sub-arrays down into strings and return a array

Spacing +12 added lines, -12 removed lines

@@ -80,7 +80,7 @@ 
      */
     public static function is_set($arr, $index, $default)
     {
-        return isset($arr[ $index ]) ? $arr[ $index ] : $default;
+        return isset($arr[$index]) ? $arr[$index] : $default;
     }
 
     /**
@@ -166,7 +166,7 @@ 
     public static function merge_arrays_and_overwrite_keys(array $array1, array $array2)
     {
         foreach ($array2 as $key => $value) {
-            $array1[ $key ] = $value;
+            $array1[$key] = $value;
         }
         return $array1;
     }
@@ -188,8 +188,8 @@ 
         $multidimensional = array();
         $reference = &$multidimensional;
         foreach ($flat_array as $key) {
-            $reference[ $key ] = array();
-            $reference = &$reference[ $key ];
+            $reference[$key] = array();
+            $reference = &$reference[$key];
         }
         if ($final_value !== null) {
             $reference = $final_value;
@@ -220,7 +220,7 @@ 
     {
         if (is_array($element)) {
             foreach ($element as $key => $value) {
-                $element[ $key ] = EEH_Array::addSlashesRecursively($value);
+                $element[$key] = EEH_Array::addSlashesRecursively($value);
             }
             return $element;
         }
@@ -242,17 +242,17 @@ 
 		foreach ($array_1 as $key => $value) {
 			if (array_key_exists($key, $array_2)) {
 				if (is_array($value)) {
-					$inner_diff = EEH_Array::array_diff_recursive($value, $array_2[ $key ]);
+					$inner_diff = EEH_Array::array_diff_recursive($value, $array_2[$key]);
 					if (count($inner_diff)) {
-						$diff[ $key ] = $inner_diff;
+						$diff[$key] = $inner_diff;
 					}
 				} else {
-					if ($value != $array_2[ $key ]) {
-						$diff[ $key ] = $value;
+					if ($value != $array_2[$key]) {
+						$diff[$key] = $value;
 					}
 				}
 			} else {
-				$diff[ $key ] = $value;
+				$diff[$key] = $value;
 			}
 		}
 		return $diff;
@@ -306,11 +306,11 @@ 
 	{
 		$flat_array = [];
 		foreach ($array as $key => $value) {
-			$flat_array[ $key ] = is_array($value)
+			$flat_array[$key] = is_array($value)
 				? EEH_Array::flattenArray($value, true, false)
 				: $value;
 		}
-		if (! $to_string) {
+		if ( ! $to_string) {
 			return $flat_array;
 		}
 		$flat = '';