Macroparts\Vortex\ArrayTools\Reorganizer

Complexity

Total Complexity

10

Size/Duplication

Total Lines	109
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	0	Features	1

8 Methods

Rating	Name	Duplication	Size	Complexity
A	patchArray()	0	14	2
A	executeUnsets()	0	6	2
A	runTask()	0	4	1
A	executeRead()	0	4	1
A	executeWrite()	0	4	1
A	scheduleUnset()	0	4	1
A	executeCast()	0	4	1
A	executeCustom()	0	5	1

<?php
/**
 * Created by PhpStorm.
 * User: daniel.jurkovic
 * Date: 15.06.17
 * Time: 13:23
 */

namespace Macroparts\Vortex\ArrayTools;

/**
 * Class Patcher
 * @package Macroparts\Vortex\ArrayPatcher
 */
class Reorganizer
{
    const CAST = 'executeCast';
    const READ = 'executeRead';
    const WRITE = 'executeWrite';
    const DELETE = 'scheduleUnset';
    const CUSTOM_TRANSFORM = 'executeCustom';

    private $scheduledUnsets = [];

    /**
     * Execute $tasks on $array and return result
     * @param array $array
     * @param array[] $tasks
     * @return array (patched)
     */
    public function patchArray(&$array, $tasks)
    {
        $temporaryValue = null;

        while ($tasks) {

The expression $tasks of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            $taskName = array_shift($tasks);
            $taskParams = array_shift($tasks);
            $this->runTask($array, $taskName, $taskParams, $temporaryValue);
        }

        $this->executeUnsets($array);

        return $array;
    }

    /**
     * @param array $array
     */
    private function executeUnsets(&$array)
    {
        foreach ($this->scheduledUnsets as $path => $nobodyCares) {
            RecursiveAccessor::unsetInPath($array, $path);
        }
    }

    /**
     * @uses executeCast
     * @uses executeRead
     * @uses executeWrite
     * @uses scheduleUnset
     * @uses executeCustom
     *
     * @param array $array
     * @param string $taskName
     * @param mixed $taskParams
     * @param mixed $temporaryValue
     */
    private function runTask(&$array, $taskName, $taskParams, &$temporaryValue)
    {
        $this->$taskName($array, $temporaryValue, $taskParams);
    }

    /**
     * @param array $array
     * @param mixed $temporaryValue
     * @param string $path
     */
    private function executeRead(&$array, &$temporaryValue, $path)
    {
        $temporaryValue = RecursiveAccessor::readSingleFromPath($array, $path);
    }

    /**
     * @param array $array
     * @param mixed $temporaryValue
     * @param string $path
     */
    private function executeWrite(&$array, $temporaryValue, $path)
    {
        RecursiveAccessor::integrateIntoPath($array, $path, $temporaryValue);
    }

    /**
     * @param array $array
     * @param mixed $temporaryValue
     * @param string $path
     */
    private function scheduleUnset(&$array, &$temporaryValue, $path)

The parameter $array is not used and could be removed.

The parameter $temporaryValue is not used and could be removed.

    {
        $this->scheduledUnsets[$path] = 1;
    }

    /**
     * @param array $array
     * @param mixed $temporaryValue
     * @param string $type
     */
    private function executeCast(&$array, &$temporaryValue, $type)

The parameter $array is not used and could be removed.

    {
        settype($temporaryValue, $type);
    }

    /**
     * @param array $array
     * @param mixed $temporaryValue
     * @param array $customFunction
     */
    private function executeCustom(&$array, &$temporaryValue, $customFunction)
    {
        list($callable, $parameters) = $customFunction;
        call_user_func_array($callable, array_merge([&$array, &$temporaryValue], $parameters));
    }
}