nebula\component\runnable\target\TargetBuilder

Complexity

Total Complexity

29

Size/Duplication

Total Lines	131
Duplicated Lines	0 %

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	splitParameter()	0	9	2
A	buildParameter()	0	6	2
B	buildWithString()	0	33	9
B	parseParameter()	0	27	8
A	newClassInstance()	0	10	2
A	buildName()	0	6	2
A	build()	0	13	4

<?php
namespace nebula\component\runnable\target;

use Closure;
use ReflectionClass;
use nebula\component\runnable\target\FileTarget;
use nebula\component\runnable\target\MethodTarget;
use nebula\component\runnable\target\ClosureTarget;
use nebula\component\runnable\target\FunctionTarget;
use nebula\component\runnable\target\RunnableTarget;

/**
 * 目标构造器
 */
class TargetBuilder
{
    /**
     * 构建目标
     *
     * @param string|array|Closure $runnable
     * @param array $parameter
     * @return RunnableTarget
     */
    public static function build($runnable, array $parameter = []):RunnableTarget
    {
        if ($runnable instanceof Closure) {
            return new ClosureTarget($runnable, $parameter);
        }
        if (\is_array($runnable)) {
            return new MethodTarget($runnable[0], null, $runnable[1], $parameter);
        }
        $target = self::buildWithString($runnable);
        if (count($parameter) > 0) {
            $target->setParameter($parameter);
        }
        return $target;
    }

    /**
     * 构建可执行对象
     *
     * @param string $command
     * @return RunnableTarget
     */
    protected static function buildWithString(string $command):RunnableTarget
    {
        $fileStart = \strrpos($command, '@');
        if ($fileStart === 0) {
            return new FileTarget(substr($command, 1));
        }
        $requireFile = '';
        if ($fileStart > 0) {
            $requireFile = substr($command, $fileStart+1);
            $command = substr($command, 0, $fileStart);
        }
        // for parameter list
        list($command, $parameter) = self::splitParameter($command);
        // for method
        $dynmicsMethod = strpos($command, '->');
        $splitLength = strpos($command, '#');
        $methodStart = $splitLength ?: strpos($command, '::') ?: $dynmicsMethod;
        $dynmicsMethod;
        $parameter = self::buildParameter($parameter);
        if ($methodStart > 0) {
            $splitLength = $splitLength > 0 ? 1:2;
            $methodName = substr($command, $methodStart + $splitLength);
            $command = substr($command, 0, $methodStart);
            list($className, $constructParameter) = self::splitParameter($command);
            $constructParameter = self::buildParameter($constructParameter);
            $target = new MethodTarget($className, $dynmicsMethod? $constructParameter :null, $methodName, $parameter);
        } else {
            $target = new FunctionTarget(self::buildName($command), $parameter);
        }
        if (strlen($requireFile)) {
            $target -> setRequireFile($requireFile);
        }
        return $target;
    }

    public static function newClassInstance(string $class)
    {
        list($className, $parameter) = self::splitParameter($class);
        $classRelName = self::buildName($className);
        if (is_null($parameter)) {
            return new  $classRelName;
        }
        $parameters=self::buildParameter($parameter);
        $classRef= new ReflectionClass($classRelName);
        return $classRef->newInstanceArgs($parameters);
    }

    private static function buildName(string $name)
    {
        if (preg_match('/^[\w\\\\\/.]+$/', $name) !== 1) {
            throw new \Exception(\sprintf('invaild command name: %s ', $name));
        }
        return  str_replace(['.','/'], '\\', $name);
    }

    private static function splitParameter(string $command):array
    {
        $parameter = null;
        if (strrpos($command, ')') === strlen($command) -1) {
            $paramStart = strpos($command, '(');
            $parameter = substr($command, $paramStart + 1, strlen($command) - $paramStart - 2);
            $command = substr($command, 0, $paramStart);
        }
        return [$command,$parameter];
    }

    private static function buildParameter(?string $parameter)
    {
        if (is_null($parameter)) {
            return [];
        }
        return self::parseParameter($parameter);
    }

    protected static function parseParameter(string $param)
    {
        $param = trim($param);
        if (strpos($param, '=') === 0) {
            list($prefix, $value) = explode(':', $param, 2);
            if (strpos($value, ':') === 0) {
                $value = base64_decode(substr($value, 1));
            }
            if ($prefix ==='=j' || $prefix ==='=json') {
                $params = json_decode($value);
                if (json_last_error() === JSON_ERROR_NONE) {
                    return $params;
                }
                throw new \Exception(sprintf('can not parse parameter %s', $param));
            } else {
                $params = unserialize($value);
                if (is_object($params)) {
                    return [$params];
                }
                return $params;
            }
        } else {
            $params = explode(',', trim($param, ','));
            foreach ($params as $index=>$value) {
                $params[$index]=trim($value);
            }
            return $params;
        }
    }
}