/**
* @param ParameterReflection $reflectionParameter
* @return ParameterGenerator
*/
public static function fromReflection(ParameterReflection $reflectionParameter)
{
$param = new ParameterGenerator();
$param->setName($reflectionParameter->getName());
if ($reflectionParameter->isArray()) {
$param->setType('array');
} elseif (method_exists($reflectionParameter, 'isCallable') && $reflectionParameter->isCallable()) {
$param->setType('callable');
} else {
$typeClass = $reflectionParameter->getClass();
if ($typeClass) {
$parameterType = $typeClass->getName();
$currentNamespace = $reflectionParameter->getDeclaringClass()->getNamespaceName();
if (!empty($currentNamespace) && substr($parameterType, 0, strlen($currentNamespace)) == $currentNamespace) {
$parameterType = substr($parameterType, strlen($currentNamespace) + 1);
} else {
$parameterType = '\\' . trim($parameterType, '\\');
}
$param->setType($parameterType);
}
}
$param->setPosition($reflectionParameter->getPosition());
if ($reflectionParameter->isOptional()) {
$param->setDefaultValue($reflectionParameter->getDefaultValue());
}
$param->setPassedByReference($reflectionParameter->isPassedByReference());
return $param;
}
/**
* @param ParameterReflection $reflectionParameter
* @return ParameterGenerator
*/
public static function fromReflection(ParameterReflection $reflectionParameter)
{
$param = new ParameterGenerator();
$param->setName($reflectionParameter->getName());
if ($reflectionParameter->isArray()) {
$param->setType('array');
} elseif (method_exists($reflectionParameter, 'isCallable') && $reflectionParameter->isCallable()) {
$param->setType('callable');
} else {
$typeClass = $reflectionParameter->getClass();
if ($typeClass) {
$param->setType($typeClass->getName());
}
}
$param->setPosition($reflectionParameter->getPosition());
if ($reflectionParameter->isOptional()) {
$param->setDefaultValue($reflectionParameter->getDefaultValue());
}
$param->setPassedByReference($reflectionParameter->isPassedByReference());
return $param;
}
public function testCallableTypeHint()
{
if (PHP_VERSION_ID < 50400) {
$this->markTestSkipped('`callable` is only supported in PHP >=5.4.0');
}
$parameter = new Reflection\ParameterReflection(array('ZendTest\\Code\\Reflection\\TestAsset\\CallableTypeHintClass', 'foo'), 'bar');
$this->assertEquals('callable', $parameter->getType());
}
/**
* Retrieves the type of a reflection parameter (null if none is found)
*
* @param ParameterReflection $reflectionParameter
*
* @return string|null
*/
private static function extractParameterType(ParameterReflection $reflectionParameter)
{
if ($reflectionParameter->isArray()) {
return 'array';
}
if (method_exists($reflectionParameter, 'isCallable') && $reflectionParameter->isCallable()) {
return 'callable';
}
if ($typeClass = $reflectionParameter->getClass()) {
return $typeClass->getName();
}
return null;
}
/**
* For ancient PHP versions (yes, you should upgrade to 7.0):
*
* @param ParameterReflection $reflectionParameter
*
* @return string|null
*/
private static function prePhp7ExtractFQCNTypeFromReflectionType(ParameterReflection $reflectionParameter)
{
if ($reflectionParameter->isCallable()) {
return 'callable';
}
if ($reflectionParameter->isArray()) {
return 'array';
}
if ($class = $reflectionParameter->getClass()) {
return $class->getName();
}
return null;
}
/**
* Check if parameter is an array.
*
* @param ParameterReflection $param
* @return bool
*/
protected function _isArrayParam($param)
{
$isArray = $param->isArray();
$docBlock = $param->getDeclaringFunction()->getDocBlock();
/** If array type is not set explicitly in the method interface, examine annotations */
if (!$isArray && $docBlock) {
/** This pattern will help to skip parameters declarations which precede to the current one */
$precedingParamsPattern = str_repeat('.*\\@param.*', $param->getPosition());
$paramType = str_replace('\\', '\\\\', $param->getType());
if (preg_match("/.*{$precedingParamsPattern}\\@param\\s+({$paramType}\\[\\]).*/is", $docBlock->getContents())) {
$isArray = true;
}
}
return $isArray;
}
/**
* @dataProvider paramTypeTestProvider
*/
public function testTypeReturn($param, $type)
{
$parameter = new Reflection\ParameterReflection(array('ZendTest\\Code\\Reflection\\TestAsset\\TestSampleClass5', 'doSomething'), $param);
$this->assertEquals($type, $parameter->getType());
}
/**
* Get parameter description
*
* @param ParameterReflection $param
* @return string|null
*/
public function getParamDescription(ParameterReflection $param)
{
$docBlock = $param->getDeclaringFunction()->getDocBlock();
$docBlockLines = explode("\n", $docBlock->getContents());
$pattern = "/\\@param\\s+([\\w\\\\_\\[\\]\\|]+)\\s+(\\\${$param->getName()})\\s(.*)/";
$matches = [];
foreach ($docBlockLines as $line) {
if (preg_match($pattern, $line, $matches)) {
return $matches[3];
}
}
}
/**
* Set the default value for a parameter (if it is optional)
*
* @param ZendParameterGenerator $parameterGenerator
* @param ParameterReflection $reflectionParameter
*/
private static function setOptionalParameter(ZendParameterGenerator $parameterGenerator, ParameterReflection $reflectionParameter)
{
if ($reflectionParameter->isOptional()) {
try {
$parameterGenerator->setDefaultValue($reflectionParameter->getDefaultValue());
} catch (ReflectionException $e) {
$parameterGenerator->setDefaultValue(null);
}
}
}
/**
* Get the parameter type
*
* @param ParameterReflection $param
* @return string
*/
public function getParamType(ParameterReflection $param)
{
$type = $param->getType();
if ($type == 'array') {
// try to determine class, if it's array of objects
$docBlock = $param->getDeclaringFunction()->getDocBlock();
$pattern = "/\\@param\\s+([\\w\\\\_]+\\[\\])\\s+\\\${$param->getName()}\n/";
if (preg_match($pattern, $docBlock->getContents(), $matches)) {
return $matches[1];
}
return "{$type}[]";
}
return $type;
}
