@param $call
@param $arguments

@return mixed
975848
private function unsafeFilter($call, $arguments)
    {
        $arguments[1] = isset($arguments[1]) ? $arguments[1] : null;
        $arguments[2] = false;

        return call_user_func_array([$this, $call], $arguments);
    }
1209405
public function call($call, array $params = array())
    {
        $startTime = microtime(true);

        if (!array_key_exists('culture', $params)) {
            $params['culture'] = $this->culture;
        }

        $url = $this->generateUrl($call, $params);
        $this->logger->debug('call start', array(
            'url'      => $url,
        ));

        $key = $this->cache->generateCacheKey($url);
        $content = $this->cache->get($key);
        if ($content !== false) {
            $this->logger->debug('call end', array(
                'url'      => $url,
                'cache'    => true,
                'time'     => microtime(true) - $startTime,
                'response' => $content,
            ));

            return $content;
        }

        $request = $this->createRequest($url);

        if (!ini_get('open_basedir') && filter_var(ini_get('safe_mode'), FILTER_VALIDATE_BOOLEAN) === false) {
            $request->setOption(CURLOPT_FOLLOWLOCATION, true);
        }

        $response = $request->get();

        if ($request->getError()) {
            $this->throwError('The Api call returned an error: "' . $request->getError() . '"');
        }

        if ($request->getStatusCode() == 401) {
            $this->throwError('Bad Username / Password ' . $request->getStatusCode(), '\Justimmo\Exception\AuthenticationException');
        }

        if ($request->getStatusCode() == 404) {
            $this->throwError('Api call not found: ' . $request->getStatusCode(), '\Justimmo\Exception\NotFoundException');
        }

        if ($request->getStatusCode() >= 400 && $request->getStatusCode() < 500) {
            $exception = new InvalidRequestException('The Api call returned status code ' . $request->getStatusCode());
            $exception->setResponse($request->getContent());
            $this->logger->error($exception->getMessage());

            throw $exception;
        }

        if ($request->getStatusCode() != 200) {
            $this->throwError('The Api call returned status code ' . $request->getStatusCode(), '\Justimmo\Exception\StatusCodeException');
        }

        $this->cache->set($key, $response);

        $this->logger->debug('call end', array(
            'url'      => $url,
            'cache'    => false,
            'time'     => microtime(true) - $startTime,
            'response' => $response,
        ));

        return $response;
    }
856825
public function registerCall($name, array $arguments = [])
    {
        $name = strtolower(preg_replace("/([A-Z]{1})/", "_$0", $name));

        $this->calls = array_merge($this->calls, array_filter(explode("_", $name)));

        if (count($arguments) > 0) {
            $lastIndex = count($this->calls) - 1;

            $this->calls[$lastIndex] = [$this->calls[$lastIndex], $arguments];
        }
    }
1288156
public function invokeWith($arguments = [])
    {
        if ($this->exception) {
            throw $this->exception;
        }

        if ($this->isUncallable) {
            return $this->returnValue;
        }

        if (!$arguments instanceof Arguments) {
            $arguments = new Arguments($arguments);
        }

        return $this->callMagicMethod
            ->invoke($this->mock, $this->name, $arguments);
    }
303872
public function popsCall($method, array &$arguments)
    {
        return $this->popsProxySubValue(
            call_user_func_array(array($this->popsValue(), $method), $arguments)
        );
    }
1183416
public function invokeWith($arguments = [])
    {
        if (!$arguments instanceof Arguments) {
            $arguments = new Arguments($arguments);
        }

        return $this->callTraitMethod->invoke(
            $this->mock,
            $this->traitName,
            $this->name,
            $arguments
        );
    }
972032
public function get($functionName, CompilationContext $compilationContext, Call $call, $exists)
    {
        if (isset($this->cache[$functionName])) {
            return $this->cache[$functionName].', '.SlotsCache::getExistingFunctionSlot($functionName);
        }

        if (!$exists) {
            return 'NULL, 0';
        }

        $cacheSlot = SlotsCache::getFunctionSlot($functionName);

        $number = 0;
        if (!$compilationContext->insideCycle) {
            $gatherer = $this->gatherer;
            if ($gatherer) {
                $number = $gatherer->getNumberOfFunctionCalls($functionName);
                if ($number <= 1) {
                    return 'NULL, '.$cacheSlot;
                }
            }
        }

        if ($compilationContext->insideCycle || $number > 1) {
            $functionCacheVariable = $compilationContext->symbolTable->getTempVariableForWrite('zephir_fcall_cache_entry', $compilationContext);
            $functionCacheVariable->setMustInitNull(true);
            $functionCacheVariable->setReusable(false);
            $functionCache = '&'.$functionCacheVariable->getName();
        } else {
            $functionCache = 'NULL';
        }

        $this->cache[$functionName] = $functionCache;

        return $functionCache.', '.$cacheSlot;
    }
232764
public function call($call) {
        $payload = [
            'query' => $this->filters,
            ($this->type === 'application/json' ? 'json' : 'body') => $this->body,
        ];
        
        $authArgsCount = count($this->auth);
        $headers = [
            'content-type' => $this->type
        ];
        
        if ($authArgsCount > 1) {
            $payload['auth'] = $this->auth;
        } else {
            $headers['Authorization'] = 'Bearer ' . $this->auth[0];
        }
        
        $payload['headers'] = $headers;
        
        if ((! empty($this->requestOptions)) && (is_array($this->requestOptions))) {
            $payload = array_merge_recursive($payload, $this->requestOptions);
        }
        
        $response = null;
        if ($call) {
            try {
                $response = call_user_func_array(
                        [$this, strtolower($this->method)], [$this->url, $payload]
                );
            } catch (ClientException $e) {
                $response = $e->getResponse();
            } catch (ServerException $e) {
                $response = $e->getResponse();
            }
        }
        return new Response($this, $response);
    }
840711
private function sortableCallByReference($function, $arguments)
    {
        $list = $this->sortableConcreteData();
        $params = array_merge([&$list], $arguments);
        $result = call_user_func_array($function, $params);
        if ($result) {
            $this->sortableResetArray($list);
        }
        return $result;
    }
922120
public function _call($instance, $method, $arguments = [])
    {
        if (method_exists($instance, $method)) {
            return call_user_func_array([$instance, $method], $arguments);
        }
    }
300612
private function callFindBy(string $method, array $arguments)
    {
        $whereByWithUpper = lcfirst(substr($method, 6, mb_strlen($method)));
        $whereBy = Str::convertCamelCaseToSnakeCase($whereByWithUpper);

        return $this->where($whereBy, '=', $arguments[0])->find();
    }
1146579
public function call($callback, $arguments = [])
    {
        $dependencies = $this->getMethodDependencies($callback, $arguments);

        return call_user_func_array($callback, $dependencies);
    }
387792
public function callCommand(string $command, array $arguments = [])
    {
        $newCommand = $this->getApplication()->find($command);

        $arguments['command'] = $command;

        return $newCommand->run(new ArrayInput($arguments), $this->getOutput());
    }
326622
public function make($host, array $arguments = [])
    {
        return $host === null ? $this->makeRelative($arguments) : $this->makeAbsolute($host, $arguments);
    }
1070752
private function callSessionMethod(string $name, array $arguments)
    {
        return \call_user_func_array(
            [
                $this->getFactory()->getSession(),
                $name
            ],
            $arguments
        );
    }
1109340
private function repackageCallWithNewArguments(Call $call, array $newArguments)
    {
        if ($call instanceof DefinitionCall) {
            return $this->repackageDefinitionCall($call, $newArguments);
        }

        if ($call instanceof TransformationCall) {
            return $this->repackageTransformationCall($call, $newArguments);
        }

        throw new UnsupportedCallException(
            sprintf(
                'ServicesResolver can not filter `%s` call.',
                get_class($call)
            ), $call
        );
    }
482886
public function dispatch($call = null)
    {
        $command = $this->routes->get($this->arguments->getCommand(1), false);
        if ($this->routes->get($call, false)) {
            $command = $this->routes->get($call, false);
        }
        if ($command) {
            $handler = new ClassMethodHandler($command, $this->arguments);
            return $handler->call($this->arguments);
        }
        throw new CommandNotFoundException(sprintf('Command %s is not registered.', $call));
    }