PHP ReflectionFunctionAbstract::isClosure方法代码示例

 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();
 }