public function writeMethod(\ReflectionMethod $method)
{
$args = [];
foreach ($method->getParameters() as $parameter) {
$arg = '';
if ($parameter->isArray()) {
$arg .= 'array ';
} else {
if ($parameter->getClass()) {
$arg .= '\\' . $parameter->getClass()->getName() . ' ';
}
}
if ($parameter->isPassedByReference()) {
$arg .= '&';
}
$arg .= '$' . $parameter->getName();
try {
$defaultValue = $parameter->getDefaultValue();
$arg .= ' = ' . var_export($defaultValue, true);
} catch (ReflectionException $e) {
if ($parameter->isOptional()) {
$arg .= ' = null';
}
}
$args[] = $arg;
}
$modifiers = array_diff(\Reflection::getModifierNames($method->getModifiers()), ['abstract']);
$methodName = ($method->returnsReference() ? '&' : '') . $method->getName();
$this->code[] = ' ' . implode(' ', $modifiers) . ' function ' . $methodName . '(' . implode(', ', $args) . ') {';
$this->code[] = ' $result = $this->' . $this->propertyName . '->invoke($this, \'' . $method->getName() . '\', func_get_args());';
$this->code[] = ' return $result;';
$this->code[] = ' }';
}
/**
* Returns whether this method returns a reference
*
* @return boolean True if this method returns a reference
*/
public function returnsReference()
{
if ($this->reflectionSource instanceof ReflectionMethod) {
return $this->reflectionSource->returnsReference();
} else {
return parent::returnsReference();
}
}
public static function fromReflection(\ReflectionMethod $ref)
{
$method = new static();
$method->setFinal($ref->isFinal())->setAbstract($ref->isAbstract())->setStatic($ref->isStatic())->setVisibility($ref->isPublic() ? self::VISIBILITY_PUBLIC : ($ref->isProtected() ? self::VISIBILITY_PROTECTED : self::VISIBILITY_PRIVATE))->setReferenceReturned($ref->returnsReference())->setName($ref->name);
if ($docComment = $ref->getDocComment()) {
$method->setDocblock(ReflectionUtils::getUnindentedDocComment($docComment));
}
foreach ($ref->getParameters() as $param) {
$method->addParameter(static::createParameter($param));
}
// FIXME: Extract body?
return $method;
}
public static function fromReflection(\ReflectionMethod $ref)
{
$method = new static($ref->name);
$method->setFinal($ref->isFinal())->setAbstract($ref->isAbstract())->setStatic($ref->isStatic())->setVisibility($ref->isPublic() ? self::VISIBILITY_PUBLIC : ($ref->isProtected() ? self::VISIBILITY_PROTECTED : self::VISIBILITY_PRIVATE))->setReferenceReturned($ref->returnsReference())->setBody(ReflectionUtils::getFunctionBody($ref));
$docblock = new Docblock($ref);
$method->setDocblock($docblock);
$method->setDescription($docblock->getShortDescription());
$method->setLongDescription($docblock->getLongDescription());
foreach ($ref->getParameters() as $param) {
$method->addParameter(static::createParameter($param));
}
return $method;
}
/**
* @param \ReflectionMethod $reflectionMethod
* @param \Donquixote\HastyReflectionCommon\Reflection\FunctionLike\MethodReflectionInterface $methodReflection
*/
private function assertEqualMethods(\ReflectionMethod $reflectionMethod, MethodReflectionInterface $methodReflection)
{
$this->assertEquals($reflectionMethod->isAbstract(), $methodReflection->isAbstract());
$this->assertEquals($reflectionMethod->getDeclaringClass()->getName(), $methodReflection->getDeclaringClassName());
$this->assertEquals($reflectionMethod->getDocComment(), $methodReflection->getDocComment());
$this->assertEquals($reflectionMethod->getShortName(), $methodReflection->getName());
$this->assertEquals($reflectionMethod->getName(), $methodReflection->getName());
$this->assertEquals($reflectionMethod->class . '::' . $reflectionMethod->getName(), $methodReflection->getQualifiedName());
$this->assertEquals($reflectionMethod->returnsReference(), $methodReflection->isByReference());
$this->assertEquals($reflectionMethod->isPrivate(), $methodReflection->isPrivate());
$this->assertEquals($reflectionMethod->isProtected(), $methodReflection->isProtected());
$this->assertEquals($reflectionMethod->isPublic(), $methodReflection->isPublic());
$this->assertEquals($reflectionMethod->isStatic(), $methodReflection->isStatic());
}
public final function generate(\ReflectionMethod $method)
{
$name = $method->getName();
$output = ' public function ';
if ($method->returnsReference()) {
$output .= '&';
}
$output .= $method->getName() . '(';
$separator = '';
foreach ($method->getParameters() as $param) {
$output .= $separator . $this->generateParameterDeclaration($param);
$separator = ', ';
}
$output .= ") { " . $this->generateBody($name) . " }\n";
return $output;
}
protected function canRedirected(\ReflectionMethod $source, \ReflectionMethod $target)
{
if ($target->isPublic() && !preg_match('#^__#', $source->getName()) && $source->returnsReference() == $target->returnsReference()) {
$sourceParam = $source->getParameters();
$targetParam = $target->getParameters();
// check parameters
if (count($targetParam) != count($sourceParam)) {
return false;
}
foreach ($targetParam as $idx => $to) {
$from = $sourceParam[$idx];
if ($to->isArray() != $from->isArray() || $to->getClass() != $from->getClass() || $to->isCallable() != $from->isCallable() || $to->isPassedByReference() != $from->isPassedByReference()) {
return false;
}
}
// all ok returns true
return true;
}
return false;
}
function methodData(ReflectionMethod $method)
{
$details = "";
$name = $method->getName();
if ($method->isUserDefined()) {
$details .= "{$name} is user defined\n";
}
if ($method->isInternal()) {
$details .= "{$name} is built-in\n";
}
if ($method->isAbstract()) {
$details .= "{$name} is abstract\n";
}
if ($method->isPublic()) {
$details .= "{$name} is public\n";
}
if ($method->isProtected()) {
$details .= "{$name} is protected\n";
}
if ($method->isPrivate()) {
$details .= "{$name} is private\n";
}
if ($method->isStatic()) {
$details .= "{$name} is static\n";
}
if ($method->isFinal()) {
$details .= "{$name} is final\n";
}
if ($method->isConstructor()) {
$details .= "{$name} is the constructor\n";
}
if ($method->returnsReference()) {
$details .= "{$name} returns a reference (as opposed to a value)\n";
}
return $details;
}
/**
* Creates a method code from Reflection
*
* @param Method|ParsedMethod $method Reflection for method
* @param string $body Body of method
*
* @return string
*/
protected function getOverriddenMethod($method, $body)
{
$code = preg_replace('/ {4}|\\t/', '', $method->getDocComment()) . "\n" . join(' ', Reflection::getModifierNames($method->getModifiers())) . ' function ' . ($method->returnsReference() ? '&' : '') . $method->name . '(' . join(', ', $this->getParameters($method->getParameters())) . ")\n" . "{\n" . $this->indent($body) . "\n" . "}\n";
return $code;
}
private function GenerateOverridingMethodTemplate(\ReflectionMethod $EntityMethod)
{
$MethodTemplate = self::OverriddenMethodTemplate;
$Modifiers = \Reflection::getModifierNames($EntityMethod->getModifiers());
$Modifiers[] = 'function';
if ($EntityMethod->returnsReference()) {
$Modifiers[] = '&';
}
$Modifiers = implode(' ', $Modifiers);
$Name = $EntityMethod->getName();
$Parameters = [];
$ParameterVariables = [];
foreach ($EntityMethod->getParameters() as $Parameter) {
$ParameterVariables[] = '$' . $Parameter->getName();
$Parameters[] = $this->GenerateMethodParameter($Parameter);
}
$Parameters = implode(', ', $Parameters);
$ParameterVariables = implode(', ', $ParameterVariables);
$MethodTemplate = str_replace('<Modifiers>', $Modifiers, $MethodTemplate);
$MethodTemplate = str_replace('<Name>', $Name, $MethodTemplate);
$MethodTemplate = str_replace('<Parameters>', $Parameters, $MethodTemplate);
$MethodTemplate = str_replace('<ParameterVariables>', $ParameterVariables, $MethodTemplate);
return $MethodTemplate;
}
/**
* Generates the string representation of a single method: signature, body.
*
* @param \ReflectionMethod $reflection_method
* A reflection method for the method.
*
* @return string
*/
protected function buildMethod(\ReflectionMethod $reflection_method)
{
$parameters = [];
foreach ($reflection_method->getParameters() as $parameter) {
$parameters[] = $this->buildParameter($parameter);
}
$function_name = $reflection_method->getName();
$reference = '';
if ($reflection_method->returnsReference()) {
$reference = '&';
}
$signature_line = <<<'EOS'
/**
* {@inheritdoc}
*/
EOS;
if ($reflection_method->isStatic()) {
$signature_line .= 'public static function ' . $reference . $function_name . '(';
} else {
$signature_line .= 'public function ' . $reference . $function_name . '(';
}
$signature_line .= implode(', ', $parameters);
$signature_line .= ')';
$output = $signature_line . "\n{\n";
$output .= $this->buildMethodBody($reflection_method);
$output .= "\n" . '}';
return $output;
}
protected function buildMethodSignature(\ReflectionMethod $method, bool $skipAbstract = false, bool $skipDefaultValues = false) : string
{
if ($method->isProtected()) {
$code = 'protected ';
} elseif ($method->isPrivate()) {
$code = 'private ';
} else {
$code = 'public ';
}
if ($method->isAbstract()) {
if (!$skipAbstract) {
$code .= 'abstract ';
}
} elseif ($method->isFinal()) {
$code .= 'final ';
}
if ($method->isStatic()) {
$code .= 'static ';
}
$code .= 'function ';
if ($method->returnsReference()) {
$code .= '& ';
}
$code .= $method->getName() . '(';
foreach ($method->getParameters() as $i => $param) {
if ($i > 0) {
$code .= ', ';
}
$code .= $this->buildParameterSignature($param, $skipDefaultValues);
}
$code .= ')';
if ($method->hasReturnType()) {
$type = $method->getReturnType();
if ($type->isBuiltin) {
$code .= ': ' . $type;
} else {
$code .= ': \\' . $type;
}
}
return $code;
}
/**
* Test that the proxy behaves in regard to methods like &foo() correctly
*/
public function testProxyRespectsMethodsWhichReturnValuesByReference()
{
$proxy = $this->_proxyFactory->getProxy('Doctrine\\Tests\\Models\\Forum\\ForumEntry', null);
$method = new \ReflectionMethod(get_class($proxy), 'getTopicByReference');
$this->assertTrue($method->returnsReference());
}
/**
* __get() implementation.
* @param object
* @param string property name
* @return mixed property value
* @throws MemberAccessException if the property is not defined.
*/
public static function &get($_this, $name)
{
$class = get_class($_this);
$uname = ucfirst($name);
$methods =& self::getMethods($class);
if ($name === '') {
throw new MemberAccessException("Cannot read a class '{$class}' property without name.");
} elseif (isset($methods[$m = 'get' . $uname]) || isset($methods[$m = 'is' . $uname])) {
// property getter
if ($methods[$m] === 0) {
$rm = new \ReflectionMethod($class, $m);
$methods[$m] = $rm->returnsReference();
}
if ($methods[$m] === TRUE) {
return $_this->{$m}();
} else {
$val = $_this->{$m}();
return $val;
}
} elseif (isset($methods[$name])) {
// public method as closure getter
if (PHP_VERSION_ID >= 50400) {
$rm = new \ReflectionMethod($class, $name);
$val = $rm->getClosure($_this);
} else {
$val = Nette\Utils\Callback::closure($_this, $name);
}
return $val;
} else {
// strict class
$type = isset($methods['set' . $uname]) ? 'a write-only' : 'an undeclared';
throw new MemberAccessException("Cannot read {$type} property {$class}::\${$name}.");
}
}
/**
* @param string $templateDir
* @param ReflectionMethod $method
* @param bool $cloneArguments
* @param bool $callOriginalMethods
*
* @return string
*/
private function generateMockedMethodDefinitionFromExisting($templateDir, ReflectionMethod $method, $cloneArguments, $callOriginalMethods)
{
if ($method->isPrivate()) {
$modifier = 'private';
} elseif ($method->isProtected()) {
$modifier = 'protected';
} else {
$modifier = 'public';
}
if ($method->isStatic()) {
$modifier .= ' static';
}
if ($method->returnsReference()) {
$reference = '&';
} else {
$reference = '';
}
if ($this->hasReturnType($method)) {
$returnType = (string) $method->getReturnType();
} else {
$returnType = '';
}
if (preg_match('#\\*[ \\t]*+@deprecated[ \\t]*+(.*?)\\r?+\\n[ \\t]*+\\*(?:[ \\t]*+@|/$)#s', $method->getDocComment(), $deprecation)) {
$deprecation = trim(preg_replace('#[ \\t]*\\r?\\n[ \\t]*+\\*[ \\t]*+#', ' ', $deprecation[1]));
} else {
$deprecation = false;
}
return $this->generateMockedMethodDefinition($templateDir, $method->getDeclaringClass()->getName(), $method->getName(), $cloneArguments, $modifier, $this->getMethodParameters($method), $this->getMethodParameters($method, true), $returnType, $reference, $callOriginalMethods, $method->isStatic(), $deprecation);
}
/**
* @return bool
*/
function isByReference()
{
return $this->reflectionMethod->returnsReference();
}
/**
* __get() implementation.
* @param object
* @param string property name
* @return mixed property value
* @throws MemberAccessException if the property is not defined.
*/
public static function &get($_this, $name)
{
$class = get_class($_this);
$uname = ucfirst($name);
$methods =& self::getMethods($class);
if ($name === '') {
throw new MemberAccessException("Cannot read a class '{$class}' property without name.");
} elseif (isset($methods[$m = 'get' . $uname]) || isset($methods[$m = 'is' . $uname])) {
// property getter
if ($methods[$m] === 0) {
$rm = new \ReflectionMethod($class, $m);
$methods[$m] = $rm->returnsReference();
}
if ($methods[$m] === TRUE) {
return $_this->{$m}();
} else {
$val = $_this->{$m}();
return $val;
}
} elseif (isset($methods[$name])) {
// public method as closure getter
$val = Callback::closure($_this, $name);
return $val;
} elseif (isset($methods['set' . $uname])) {
// strict class
throw new MemberAccessException("Cannot read a write-only property {$class}::\${$name}.");
} else {
// strict class
$hint = self::getSuggestion(array_merge(array_keys(get_class_vars($class)), self::parseFullDoc($class, '~^[ \\t*]*@property(?:-read)?[ \\t]+(?:\\S+[ \\t]+)??\\$(\\w+)~m')), $name);
throw new MemberAccessException("Cannot read an undeclared property {$class}::\${$name}" . ($hint ? ", did you mean \${$hint}?" : '.'));
}
}
private function assertSameMethodAttributes(\ReflectionMethod $original, ReflectionMethod $stubbed)
{
$this->assertSame(array_map(function (\ReflectionParameter $parameter) {
return $parameter->getDeclaringFunction()->getName() . '.' . $parameter->getName();
}, $original->getParameters()), array_map(function (ReflectionParameter $parameter) {
return $parameter->getDeclaringFunction()->getName() . '.' . $parameter->getName();
}, $stubbed->getParameters()));
foreach ($original->getParameters() as $parameter) {
$this->assertSameParameterAttributes($parameter, $stubbed->getParameter($parameter->getName()));
}
$this->assertSame($original->isPublic(), $stubbed->isPublic());
$this->assertSame($original->isPrivate(), $stubbed->isPrivate());
$this->assertSame($original->isProtected(), $stubbed->isProtected());
$this->assertSame($original->returnsReference(), $stubbed->returnsReference());
$this->assertSame($original->isStatic(), $stubbed->isStatic());
$this->assertSame($original->isFinal(), $stubbed->isFinal());
}
/**
* __get() implementation.
* @param object
* @param string property name
* @return mixed property value
* @throws MemberAccessException if the property is not defined.
*/
public static function &get($_this, $name)
{
$class = get_class($_this);
$uname = ucfirst($name);
if (!isset(self::$methods[$class])) {
self::$methods[$class] = array_flip(get_class_methods($class));
// public (static and non-static) methods
}
if ($name === '') {
throw new MemberAccessException("Cannot read a class '{$class}' property without name.");
} elseif (isset(self::$methods[$class][$m = 'get' . $uname]) || isset(self::$methods[$class][$m = 'is' . $uname])) {
// property getter
$isRef =& self::$methods[$class][$m];
if (!is_bool($isRef)) {
$rm = new \ReflectionMethod($class, $m);
$isRef = $rm->returnsReference();
}
if ($isRef) {
return $_this->{$m}();
} else {
$val = $_this->{$m}();
return $val;
}
} elseif (isset(self::$methods[$class][$name])) {
// public method as closure getter
$val = Callback::create($_this, $name);
return $val;
} else {
// strict class
$type = isset(self::$methods[$class]['set' . $uname]) ? 'a write-only' : 'an undeclared';
throw new MemberAccessException("Cannot read {$type} property {$class}::\${$name}.");
}
}
/**
* Creates the implementation of a single method
*
* @param ReflectionMethod $method
*
* @return string
*/
protected function implementMethod(ReflectionMethod $method, $static = false)
{
$modifiers = implode(' ', Reflection::getModifierNames($method->getModifiers() & ~ReflectionMethod::IS_ABSTRACT));
$reference = $method->returnsReference() ? '&' : '';
if ($static) {
$context = '__CLASS__';
} else {
$context = '$this';
}
$docComment = $method->getDocComment() ?: '';
$methodDef = "\n\t{$docComment}\n\t{$modifiers} function {$reference}{$method->getName()}({$this->generateMethodParameters($method)})\n\t{\n\t\t\$__PHAKE_args = array();\n\t\t{$this->copyMethodParameters($method)}\n\n \$__PHAKE_info = Phake::getInfo({$context});\n\t\tif (\$__PHAKE_info === null) {\n\t\t return null;\n\t\t}\n\n\t\t\$__PHAKE_funcArgs = func_get_args();\n\t\t\$__PHAKE_answer = \$__PHAKE_info->getHandlerChain()->invoke({$context}, '{$method->getName()}', \$__PHAKE_funcArgs, \$__PHAKE_args);\n\n\t \$__PHAKE_callback = \$__PHAKE_answer->getAnswerCallback({$context}, '{$method->getName()}');\n\t \$__PHAKE_result = call_user_func_array(\$__PHAKE_callback, \$__PHAKE_args);\n\t \$__PHAKE_answer->processAnswer(\$__PHAKE_result);\n\t return \$__PHAKE_result;\n\t}\n";
return $methodDef;
}
protected function generateMethodDefinitionFromExisting(ReflectionMethod $method)
{
if ($method->isPrivate()) {
$modifier = 'private';
} else {
if ($method->isProtected()) {
$modifier = 'protected';
} else {
$modifier = 'public';
}
}
if ($method->isStatic()) {
$modifier .= ' static';
}
if ($method->returnsReference()) {
$reference = '&';
} else {
$reference = '';
}
return $this->generateMethodDefinition($method->getDeclaringClass()->getName(), $method->getName(), $modifier, $reference, PHPUnit_Util_Class::getMethodParameters($method));
}
/**
* @param string $templateDir
* @param ReflectionMethod $method
* @return string
*/
protected static function generateMockedMethodDefinitionFromExisting($templateDir, ReflectionMethod $method)
{
if ($method->isPrivate()) {
$modifier = 'private';
} else {
if ($method->isProtected()) {
$modifier = 'protected';
} else {
$modifier = 'public';
}
}
if ($method->isStatic()) {
$static = TRUE;
} else {
$static = FALSE;
}
if ($method->returnsReference()) {
$reference = '&';
} else {
$reference = '';
}
return self::generateMockedMethodDefinition($templateDir, $method->getDeclaringClass()->getName(), $method->getName(), $modifier, PHPUnit_Util_Class::getMethodParameters($method), PHPUnit_Util_Class::getMethodParameters($method, TRUE), $reference, $static);
}
function methodData(ReflectionMethod $method)
{
$details = "";
$name = $method->getName();
if ($method->isUserDefined()) {
$details .= "{$name} -- метод определён пользователем<br>";
}
if ($method->isInternal()) {
$details .= "{$name} -- внутренний метод<br>";
}
if ($method->isAbstract()) {
$details .= "{$name} -- абстрактный метод<br>";
}
if ($method->isPublic()) {
$details .= "{$name} -- публичный метод<br>";
}
if ($method->isProtected()) {
$details .= "{$name} -- защищенный метод<br>";
}
if ($method->isPrivate()) {
$details .= "{$name} -- закрытый метод метод<br>";
}
if ($method->isStatic()) {
$details .= "{$name} -- статичный метод<br>";
}
if ($method->isFinal()) {
$details .= "{$name} -- финальный метод<br>";
}
if ($method->isConstructor()) {
$details .= "{$name} -- метод конструктора<br>";
}
if ($method->returnsReference()) {
$details .= "{$name} -- метод возвращает ссылку а не значение<br>";
}
return $details;
}
/**
* Returns the signature of a method.
*
* @param ReflectionMethod $method
* @return string
* @since Method available since Release 3.2.0
*/
public static function getMethodSignature(ReflectionMethod $method)
{
if ($method->isPrivate()) {
$modifier = 'private';
} else {
if ($method->isProtected()) {
$modifier = 'protected';
} else {
$modifier = 'public';
}
}
if ($method->isStatic()) {
$modifier .= ' static';
}
if ($method->returnsReference()) {
$reference = '&';
} else {
$reference = '';
}
return sprintf('%s function %s%s(%s)', $modifier, $reference, $method->getName(), self::getMethodParameters($method));
}
/**
* Generates the definition of a method to be proxied.
*
* @param string $templateDir Location of the templates to be used to create the proxy.
* @param \ReflectionMethod $method Name of the method to be reflected.
*
* @return array Information about the method to be proxied.
*/
protected static function generateProxiedMethodDefinition($templateDir, \ReflectionMethod $method)
{
$reference = '';
if ($method->returnsReference()) {
$reference = '&';
}
$template = self::createTemplateObject($templateDir . 'proxied_method.tpl');
$template->setVar(array('arguments_declaration' => self::getArgumentDeclaration($method), 'arguments' => self::getMethodCallParameters($method), 'method_name' => $method->getName(), 'reference' => $reference));
return $template->render();
}
/**
* Replace abstract protected methods (the only enforceable type outside
* of public methods). The replacement is just a stub that does nothing.
*/
protected static function _replaceProtectedAbstractMethod(ReflectionMethod $method)
{
$name = $method->getName();
if (self::_isReservedWord($name)) {
return " /* Could not replace {$name}() as it is a reserved word */ ";
}
$body = '';
$methodParams = array();
$params = $method->getParameters();
foreach ($params as $param) {
$paramDef = '';
if ($param->isArray()) {
$paramDef .= 'array ';
} elseif ($param->getClass()) {
$paramDef .= $param->getClass()->getName() . ' ';
}
$paramDef .= ($param->isPassedByReference() ? '&' : '') . '$' . $param->getName();
if ($param->isDefaultValueAvailable()) {
$default = var_export($param->getDefaultValue(), true);
if ($default == '') {
$default = 'null';
}
$paramDef .= ' = ' . $default;
} else {
if ($param->isOptional()) {
$paramDef .= ' = null';
}
}
$methodParams[] = $paramDef;
}
$paramDef = implode(',', $methodParams);
$access = 'protected';
$returnByRef = $method->returnsReference() ? ' & ' : '';
return $access . ' function ' . $returnByRef . $name . '(' . $paramDef . ')' . '{' . $body . '}';
}
/**
* @param string $templateDir
* @param ReflectionMethod $method
* @param boolean $cloneArguments
* @param boolean $callOriginalMethods
*
* @return string
*/
protected function generateMockedMethodDefinitionFromExisting($templateDir, ReflectionMethod $method, $cloneArguments, $callOriginalMethods)
{
if ($method->isPrivate()) {
$modifier = 'private';
} elseif ($method->isProtected()) {
$modifier = 'protected';
} else {
$modifier = 'public';
}
if ($method->isStatic()) {
$modifier .= ' static';
}
if ($method->returnsReference()) {
$reference = '&';
} else {
$reference = '';
}
return $this->generateMockedMethodDefinition($templateDir, $method->getDeclaringClass()->getName(), $method->getName(), $cloneArguments, $modifier, $this->getMethodParameters($method), $this->getMethodParameters($method, true), $reference, $callOriginalMethods, $method->isStatic());
}
/**
* __get() implementation.
* @param object
* @param string property name
* @return mixed property value
* @throws MemberAccessException if the property is not defined.
*/
public static function &get($_this, $name)
{
$class = get_class($_this);
$uname = ucfirst($name);
$methods =& self::getMethods($class);
if ($name === '') {
throw new MemberAccessException("Cannot read a class '{$class}' property without name.");
} elseif (isset($methods[$m = 'get' . $uname]) || isset($methods[$m = 'is' . $uname])) {
// property getter
if ($methods[$m] === 0) {
$rm = new \ReflectionMethod($class, $m);
$methods[$m] = $rm->returnsReference();
}
if ($methods[$m] === TRUE) {
return $_this->{$m}();
} else {
$val = $_this->{$m}();
return $val;
}
} elseif (isset($methods[$name])) {
// public method as closure getter
if (preg_match('#^(is|get|has)([A-Z]|$)#', $name) && ($rm = new \ReflectionMethod($class, $name)) && !$rm->getNumberOfRequiredParameters()) {
$source = '';
foreach (debug_backtrace(PHP_VERSION_ID >= 50306 ? DEBUG_BACKTRACE_IGNORE_ARGS : FALSE) as $item) {
if (isset($item['file']) && dirname($item['file']) !== __DIR__) {
$source = " in {$item['file']}:{$item['line']}";
break;
}
}
trigger_error("Did you forgot parentheses after {$name}{$source}?", E_USER_WARNING);
}
$val = Callback::closure($_this, $name);
return $val;
} elseif (isset($methods['set' . $uname])) {
// strict class
throw new MemberAccessException("Cannot read a write-only property {$class}::\${$name}.");
} else {
// strict class
$hint = self::getSuggestion(array_merge(array_keys(get_class_vars($class)), self::parseFullDoc($class, '~^[ \\t*]*@property(?:-read)?[ \\t]+(?:\\S+[ \\t]+)??\\$(\\w+)~m')), $name);
throw new MemberAccessException("Cannot read an undeclared property {$class}::\${$name}" . ($hint ? ", did you mean \${$hint}?" : '.'));
}
}
/**
* Creates the implementation of a single method
*
* @param ReflectionMethod $method
*
* @return string
*/
protected function implementMethod(ReflectionMethod $method)
{
$modifiers = implode(' ', Reflection::getModifierNames($method->getModifiers() & ~ReflectionMethod::IS_ABSTRACT));
$reference = $method->returnsReference() ? '&' : '';
$methodDef = "\n\t{$modifiers} function {$reference}{$method->getName()}({$this->generateMethodParameters($method)})\n\t{\n\t\t\$args = array();\n\t\t{$this->copyMethodParameters($method)}\n\t\t\n\t\t\$funcArgs = func_get_args();\n\t\t\$answer = \$this->__PHAKE_handlerChain->invoke(\$this, '{$method->getName()}', \$funcArgs, \$args);\n\t\t\n\t\tif (\$answer instanceof Phake_Stubber_Answers_IDelegator)\n\t\t{\n\t\t\t\$delegate = \$answer->getAnswer();\n\t\t\t\$callback = \$delegate->getCallBack(\$this, '{$method->getName()}', \$args);\n\t\t\t\$arguments = \$delegate->getArguments('{$method->getName()}', \$args);\n\n\t\t\t\$realAnswer = call_user_func_array(\$callback, \$arguments);\n\t\t\t\$answer->processAnswer(\$realAnswer);\n\t\t\treturn \$realAnswer;\n\t\t}\n\t\telse\n\t\t{\n\t\t\t\$returnAnswer = \$answer->getAnswer();\n\t\t\treturn \$returnAnswer;\n\t\t}\n\t}\n";
return $methodDef;
}
<?php
class TestClass
{
public function &foo()
{
}
private function bar()
{
}
}
$methodInfo = new ReflectionMethod('TestClass::foo');
var_dump($methodInfo->returnsReference());
$methodInfo = new ReflectionMethod('TestClass::bar');
var_dump($methodInfo->returnsReference());
