Flipbox\Transform\Helpers\ArgumentHelper

Complexity

Total Complexity

25

Size/Duplication

Total Lines	182
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

0%

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	closure()	0	17	3
A	callable()	0	21	4
A	mergeCallable()	0	11	2
A	mergeClosure()	0	7	1
A	mergeParameters()	0	11	2
B	interpretFunction()	0	32	7
B	argType()	0	25	6

<?php

/**
 * @author    Flipbox Factory
 * @copyright Copyright (c) 2017, Flipbox Digital
 * @link      https://github.com/flipbox/transform/releases/latest
 * @license   https://github.com/flipbox/transform/blob/master/LICENSE
 */

namespace Flipbox\Transform\Helpers;

/**
 * @author Flipbox Factory <hello@flipboxfactory.com>
 * @since 3.0.0
 */
class ArgumentHelper
{
    /**
     * Extracts all of the valid arguments for a provided Closure.
     *
     * @param $transformer
     * @param array $params
     * @return array
     */
    public static function closure(\Closure $transformer, array $params): array
    {
        if (empty($params)) {
            return $params;
        }

        try {
            return self::interpretFunction(
                new \ReflectionFunction($transformer),
                $params
            );
        } catch (\ReflectionException $e) {
            // Sorry
        }

        return [];
    }

    /**
     * Extracts all of the valid arguments for a provided callable.
     *
     * @param callable $transformer
     * @param array $params
     * @param string $method
     * @return array
     */
    public static function callable(callable $transformer, array $params, string $method = 'transform'): array
    {
        if (TransformerHelper::isClosure($transformer)) {
            return static::closure($transformer, $params);

$transformer is of type callable, but the function expects a object<Closure>.

        }

        if (empty($params)) {
            return $params;
        }

        try {
            return self::interpretFunction(
                new \ReflectionMethod($transformer, $method),
                $params
            );
        } catch (\ReflectionException $e) {
            // Sorry
        }

        return [];
    }

    /**
     * Merges an indexed array of arguments values with their name.  Note, the orders MUST match.
     *
     * @param callable $transformer
     * @param array $params
     * @param string $method
     * @return array
     * @throws \ReflectionException
     */
    public static function mergeCallable(callable $transformer, array $params, string $method = 'transform'): array
    {
        if (TransformerHelper::isClosure($transformer)) {
            return static::mergeClosure($transformer, $params);
        }

        return self::mergeParameters(
            new \ReflectionMethod($transformer, $method),
            $params
        );
    }

    /**
     * Merges an indexed array of arguments values with their name.  Note, the orders MUST match.
     *
     * @param callable $transformer
     * @param array $params
     * @return array
     * @throws \ReflectionException
     */
    public static function mergeClosure(callable $transformer, array $params): array
    {
        return self::mergeParameters(
            new \ReflectionFunction($transformer),
            $params
        );
    }


    /**
     * @param \ReflectionFunctionAbstract $function
     * @param array $params
     * @return array
     */
    private static function mergeParameters(\ReflectionFunctionAbstract $function, array $params): array
    {
        $args = [];

        foreach ($function->getParameters() as $key => $param) {
            $name = $param->name;
            $args[$name] = $params[$key] ?? null;
        }

        return $args;
    }

    /**
     * @param \ReflectionFunctionAbstract $function
     * @param array $params
     * @return array
     * @throws \InvalidArgumentException
     */
    private static function interpretFunction(\ReflectionFunctionAbstract $function, array $params): array
    {
        $args = $missing = [];
        foreach ($function->getParameters() as $param) {
            $name = $param->name;
            if (true === in_array($name, ['data'], true)) {
                continue;
            }

            if (array_key_exists($name, $params)) {
                $args[$name] = static::argType($param, $params[$name]);

Since argType() is declared private, calling it with static will lead to errors in possible sub-classes. You can either use self, or increase the visibility of argType() to at least protected.

            } elseif ($param->isDefaultValueAvailable()) {
                $args[$name] = $param->getDefaultValue();
            } elseif ($param->isVariadic()) {
                $args = array_merge(
                    $args,
                    ${$param->name}
                );
            } else {
                $missing[$name] = $name;
            }
        }

        if (!empty($missing)) {
            throw new \InvalidArgumentException(sprintf(
                'Missing required parameters "%s".',
                implode(', ', $missing)
            ));
        }

        return $args;
    }

    /**
     * @param \ReflectionParameter $param
     * @param $value
     * @return mixed
     */
    private static function argType(
        \ReflectionParameter $param,
        $value
    ) {
        if (!$param->hasType()) {
            return $value;
        }

        if ($param->isArray()) {
            return (array)$value;
        }

        if ($param->isCallable() && is_callable($value)) {
            return $value;
        }

        if (!is_array($value)) {
            return $value;
        }

        throw new \InvalidArgumentException(sprintf(
            'Invalid data received for parameter "%s".',
            $param->name
        ));
    }
}