private function getFunctionName(\ReflectionFunctionAbstract $reflectionFunction) { if ($reflectionFunction->isClosure()) { return sprintf('closure defined in %s at line %d', $reflectionFunction->getFileName(), $reflectionFunction->getStartLine()); } elseif ($reflectionFunction instanceof \ReflectionMethod) { return sprintf('%s::%s', $reflectionFunction->getDeclaringClass()->getName(), $reflectionFunction->getName()); } return $reflectionFunction->getName(); }
/** * Print the signature of the target action. * * @return string */ public function __toString() { if ($this->target instanceof \ReflectionMethod) { return sprintf('%s->%s()', $this->target->getDeclaringClass()->name, $this->target->name); } if ($this->target instanceof \ReflectionFunction && !$this->target->isClosure()) { return $this->target->getName() . '()'; } return '*closure*'; }
/** * Creates a function scope instance from the supplied reflection and callable. * * @param \ReflectionFunctionAbstract $reflection * @param callable $callable * * @return self */ public static function fromReflection(\ReflectionFunctionAbstract $reflection, callable $callable) { if (is_array($callable)) { /** @var $reflection \ReflectionMethod */ $thisObject = is_object($callable[0]) ? $callable[0] : null; $scopeType = $reflection->getDeclaringClass()->getName(); } elseif (is_object($callable) && !$callable instanceof \Closure) { /** @var $reflection \ReflectionMethod */ $thisObject = $callable; $scopeType = $reflection->getDeclaringClass()->getName(); } elseif ($reflection->isClosure()) { $thisObject = $reflection->getClosureThis(); $scopeClass = $reflection->getClosureScopeClass(); $scopeType = $scopeClass === null ? null : $scopeClass->getName(); } else { $thisObject = null; $scopeType = null; } $variableTable = $reflection->getStaticVariables(); return new self($thisObject, $scopeType, $variableTable); }
/** * Get called method from abstract reflection function * * @param \ReflectionFunctionAbstract $method * @param bool $closureInfo * * @return string */ public static function getCalledMethod(\ReflectionFunctionAbstract $method, $closureInfo = true) { if ($method->isClosure()) { if ($closureInfo) { return sprintf('Closure [%s:%d]', $method->getFileName(), $method->getStartLine()); } return 'Closure'; } if ($method instanceof \ReflectionMethod) { return sprintf('%s::%s', $method->getDeclaringClass()->getName(), $method->getName()); } return $method->getName(); }
function it_returns_its_line_number_as_zero_if_constructed_with_closure(\ReflectionFunctionAbstract $function) { $function->isClosure()->willReturn(true); $this->getLineNumber()->shouldReturn(0); }
/** * Merges found arguments with multiliners and maps them to the function callback signature. * * @param ContextInterface $context context instance * @param \ReflectionFunctionAbstract $refl callback reflection * @param array $arguments found arguments * @param array $multiline multiline arguments of the step * * @return array */ private function prepareCallbackArguments(ContextInterface $context, \ReflectionFunctionAbstract $refl, array $arguments, array $multiline) { $parametersRefl = $refl->getParameters(); if ($refl->isClosure()) { array_shift($parametersRefl); } $resulting = array(); foreach ($parametersRefl as $num => $parameterRefl) { if (isset($arguments[$parameterRefl->getName()])) { $resulting[] = $arguments[$parameterRefl->getName()]; } elseif (isset($arguments[$num])) { $resulting[] = $arguments[$num]; } } foreach ($multiline as $argument) { $resulting[] = $argument; } return $resulting; }
protected function getCallbackSignature(\ReflectionFunctionAbstract $ref) { if ($ref instanceof \ReflectionMethod) { return $ref->getDeclaringClass()->name . '->' . $ref->name . '()'; } if ($ref->isClosure()) { return '*closure*'; } return $ref->name . '()'; }
/** * @return int */ public function getLineNumber() { return $this->function->isClosure() ? 0 : $this->function->getStartLine(); }