Execute a Predis command.

@param string $name
@param array  $arguments

@return string
420031
protected function executeCommand($name, array $arguments)
    {
        $command = $this->client->createCommand($name, $arguments);

        return $this->client->executeCommand($command);
    }
218222
public function execute($name, $args, $trackedArgs = [])
    {
        $connection = $this->getConnection($name, $args);

        $failure = false;
        RETRY_COMMAND:
        {
            try {
                $response = $connection->execute($name, $args, $trackedArgs);
            } catch (RedisException $exception) {
                $connection->close();
                $this->remove($connection);
                if ($failure) {
                    throw $exception;
                }

                $this->askSlotsMap();
                $failure = true;
                goto RETRY_COMMAND;
            }
        }

        if ($response instanceof RedisException) {
            return $this->onErrorResponse($name, $args, $response);
        }

        return $response;
    }
99514
protected function format($name, array $args = null)
    {
        $result = ['name' => $name];
        if ($args !== null) {
            $result['args'] = $args;
        }

        return $result;
    }
973106
public function execBinary($name, $args = '', $returnExitCode = false)
    {
        return $this->get($name)->exec($args, $returnExitCode);
    }
818229
private function executeMethod(array $arguments)
    {
        if ($this->reflection->isStatic()) {
            return $this->reflection->invokeArgs(null, $arguments);
        } elseif (is_object($this->callback[0])) {
            return $this->reflection->invokeArgs($this->callback[0], $arguments);
        }
        $instance = new $this->callback[0]();
        return $this->reflection->invokeArgs($instance, $arguments);
    }
1226867
public function render($name, array $args = array())
    {
        if ($this->has($name)) {
            $callback = $this->widgets[$name];

            return $this->executeCallback($callback, $args);
        }

        return '';
    }
10929
public function get($name, array $arguments = null)
    {
        $this->load();
        if ($arguments === null) {
            $arguments = [$this->env];
        }
        if (isset($this->config[$name])) {
            $entry = $this->config[$name];
            if (is_callable($entry)) {
                return $entry(...$arguments);
            } elseif (is_object($entry)) {
                return $entry;
            } else {
                $name = $entry;
            }
        }
        return new $name(...$arguments);
    }
573324
protected function execute(CommandInterface $command, array $arguments)
	{
		return $this->container->call([$command, 'execute'], $this->convertArgumentsToCamelCase($arguments));
	}
1038844
public function callInterceptor(string $name, ...$arguments)
    {
        if (!empty($this->interceptors[$name])) {
            foreach ($this->interceptors[$name] as $function) {
                $ret = Helper::call($function, ...$arguments);
                if ($ret !== null) {
                    return $ret;
                }
            }
        }

        return null;
    }
1348578
protected function cutArgument($name, &$args)
    {
        if (isset($args[$name])) {
            $result = $args[$name];
            unset($args[$name]);
            return $result;
        }

        return null;
    }
888016
protected function exec($command, $arguments = [], $options = [])
    {
        $arguments = implode(' ', (array) $arguments);
        $options   = implode(' ', (array) $options);

        $command = sprintf('%s %s %s', $command, $arguments, $options);

        $this->out('>> ' . $command);

        if ($this->io->getOption('dry-run')) {
            return '';
        }

        $return = exec(trim($command), $this->lastOutput, $this->lastReturn);

        $this->out($return);
    }
355744
public function __callBefore($name, $arguments)
	{
		if(isset($arguments[0]))
		{
			// getBy字段支持：
			$arr = explode('getBy',$name);
			if(''===$arr[0] && isset($arr[1]))
			{
				return $this->getBy($arr[1], $arguments[0]);
			}
			// selectBy字段支持：
			$arr = explode('selectBy',$name);
			if(''===$arr[0] && isset($arr[1]))
			{
				return $this->selectBy($arr[1], $arguments[0]);
			}
			unset($arr);
			// 全部转为小写，照顾所有大小写习惯的用户
			$name = strtolower($name);
		}
	}
337731
protected function newMethod($name, array $arguments = [])
    {
        return O\Expression::methodCall(
                $this->expression,
                O\Expression::value($name),
                array_map([O\Expression::getType(), 'argument'], array_map([O\Expression::getType(), 'value'], $arguments))
        );
    }
610118
public function getCommand($name, array $args = [])
    {
        if (!$this->description->hasOperation($name)) {
            $name = ucfirst($name);
            if (!$this->description->hasOperation($name)) {
                throw new \InvalidArgumentException(
                    "No operation found named {$name}"
                );
            }
        }

        // Merge in default command options
        $args += $this->getConfig('defaults');

        return parent::getCommand($name, $args);
    }
887192
public function passthru(array $arguments = [])
    {
        passthru($this->getBin() . $this->prepareCommand($arguments), $exitCode);
        return $exitCode;
    }
135416
public static function trigger($name, $args) {
        if (array_key_exists($name, static::$events)) {
            $infos = static::$events[ $name ];
            if ($infos) {
                foreach ($infos as $info) {
                    $module = Ioc::get($info[ 'class' ]);
                    if ($info[ 'action' ]) {
                        static::doAction($module, $info[ 'action' ], $args);
                    }
                }
            }
        }
    }
576692
public function delete(string $name, $arguments = null)
    {
        $this->name || $this->key($name, $arguments);
        $result = $this->doDelete();

        $this->reset();

        return $result;
    }