/**
* @param \ReflectionParameter $parameter
* @return mixed
*/
private function getArgumentMock(\ReflectionParameter $parameter)
{
if ($parameter->getClass() !== null) {
return $this->testCase->getMockBuilder($parameter->getClass()->getName())->disableOriginalConstructor()->getMock();
}
throw new \Mocktainer\UnmockableMethodArgumentException($parameter->getDeclaringClass()->getName(), $parameter->getDeclaringFunction()->getName(), $parameter->getName());
}
public function getParamTypeHint(\ReflectionFunctionAbstract $function, \ReflectionParameter $param, array $arguments = [])
{
$lowParam = strtolower($param->name);
if ($function instanceof \ReflectionMethod) {
$lowClass = strtolower($function->class);
$lowMethod = strtolower($function->name);
$paramCacheKey = self::CACHE_KEY_CLASSES . "{$lowClass}.{$lowMethod}.param-{$lowParam}";
} else {
$lowFunc = strtolower($function->name);
$paramCacheKey = $lowFunc !== '{closure}' ? self::CACHE_KEY_FUNCS . ".{$lowFunc}.param-{$lowParam}" : null;
}
$typeHint = $paramCacheKey === null ? false : $this->cache->fetch($paramCacheKey);
if (false !== $typeHint) {
return $typeHint;
}
if ($reflectionClass = $param->getClass()) {
$typeHint = $reflectionClass->getName();
$classCacheKey = self::CACHE_KEY_CLASSES . strtolower($typeHint);
$this->cache->store($classCacheKey, $this->getClass($param->getClass()->getName()));
} elseif ($function instanceof \ReflectionMethod && ($docBlockParams = $this->getDocBlock($function)->getTagsByName('param')) && !empty($docBlockParams)) {
$typeHint = $this->getParamDocBlockHint($docBlockParams, $param, $arguments);
// store the ExtendedReflectionClass in the cache
if ($typeHint !== false) {
$classCacheKey = self::CACHE_KEY_CLASSES . strtolower($typeHint);
$this->cache->store($classCacheKey, $this->getClass($typeHint));
}
} else {
$typeHint = null;
}
$this->cache->store($paramCacheKey, $typeHint);
return $typeHint;
}
/**
* @return self
*/
public static function from(\ReflectionParameter $from)
{
$param = new static($from->getName());
$param->reference = $from->isPassedByReference();
if (PHP_VERSION_ID >= 70000) {
$param->typeHint = $from->hasType() ? (string) $from->getType() : NULL;
} elseif ($from->isArray()) {
$param->typeHint = 'array';
} elseif (PHP_VERSION_ID >= 50400 && $from->isCallable()) {
$param->typeHint = 'callable';
} else {
try {
$param->typeHint = $from->getClass() ? $from->getClass()->getName() : NULL;
} catch (\ReflectionException $e) {
if (preg_match('#Class (.+) does not exist#', $e->getMessage(), $m)) {
$param->typeHint = $m[1];
} else {
throw $e;
}
}
}
$param->optional = PHP_VERSION_ID < 50407 ? $from->isOptional() || $param->typeHint && $from->allowsNull() : $from->isDefaultValueAvailable();
$param->defaultValue = PHP_VERSION_ID === 50316 ? $from->isOptional() : $from->isDefaultValueAvailable() ? $from->getDefaultValue() : NULL;
return $param;
}
/**
* @return self
*/
public static function from(\ReflectionParameter $from)
{
$param = new static();
$param->name = $from->getName();
$param->reference = $from->isPassedByReference();
if ($from->isArray()) {
$param->typeHint = 'array';
} elseif (PHP_VERSION_ID >= 50400 && $from->isCallable()) {
$param->typeHint = 'callable';
} else {
try {
$param->typeHint = $from->getClass() ? '\\' . $from->getClass()->getName() : NULL;
} catch (\ReflectionException $e) {
if (preg_match('#Class (.+) does not exist#', $e->getMessage(), $m)) {
$param->typeHint = '\\' . $m[1];
} else {
throw $e;
}
}
}
$param->optional = PHP_VERSION_ID < 50407 ? $from->isOptional() || $param->typeHint && $from->allowsNull() : $from->isDefaultValueAvailable();
$param->defaultValue = PHP_VERSION_ID === 50316 ? $from->isOptional() : $from->isDefaultValueAvailable() ? $from->getDefaultValue() : NULL;
$namespace = $from->getDeclaringClass() ? $from->getDeclaringClass()->getNamespaceName() : NULL;
$namespace = $namespace ? "\\{$namespace}\\" : '\\';
if (Nette\Utils\Strings::startsWith($param->typeHint, $namespace)) {
$param->typeHint = substr($param->typeHint, strlen($namespace));
}
return $param;
}
public function getDeclaration()
{
if ($this->reflector->isArray()) {
$code = 'array ';
} else {
$class = $this->reflector->getClass();
if ($class !== null) {
$code = $class->name . ' ';
} else {
$code = '';
}
}
$code .= '$' . $this->reflector->name;
if ($this->reflector->isOptional()) {
$default = $this->reflector->getDefaultValue();
if (is_null($default)) {
$default = 'null';
} elseif (is_bool($default)) {
$default = $default ? 'true' : 'false';
} elseif (is_string($default)) {
$default = "'" . $default . "'";
} elseif (is_numeric($default)) {
$default = strval($default);
} elseif (is_array($default)) {
$default = 'array()';
} else {
echo 'Warning: unknown default type for ' . $this->getMethod()->getFullName() . PHP_EOL;
var_dump($default);
$default = 'null';
}
$code .= ' = ' . $default;
}
return $code;
}
/**
* @param string $className
* @param string $argumentName
* @param \ReflectionParameter $parameter
* @return mixed
*/
private function getArgumentMock(string $className, string $argumentName, \ReflectionParameter $parameter)
{
if ($parameter->getClass() !== null) {
return $this->testCase->getMockBuilder($parameter->getClass()->name)->disableOriginalConstructor()->getMock();
}
throw new \Mocktainer\UnmockableConstructorArgumentException($className, $argumentName);
}
private function isGoutte1()
{
$refl = new \ReflectionParameter(array('Goutte\\Client', 'setClient'), 0);
if ($refl->getClass() && 'Guzzle\\Http\\ClientInterface' === $refl->getClass()->getName()) {
return true;
}
return false;
}
/**
* @inheritdoc
*/
public function getClass()
{
$class = $this->parameter->getClass();
if ($class) {
return $class->getName();
}
return null;
}
private function getParameterInfo(\ReflectionParameter $parameter)
{
$paramName = '$' . $parameter->getName() . '=null';
if ($parameter->isPassedByReference()) {
$paramName = '&' . $paramName;
}
$paramType = $parameter->getClass() !== null ? $parameter->getClass()->getName() : '';
return "{$paramType} {$paramName}";
}
/**
* return type hint, if any (none or object type - inteface, class, ...)
*
* @return string
*/
public function getTypeHint()
{
if ($this->typeHint === null) {
if (($class = $this->reflectionParameter->getClass()) !== null) {
$this->typeHint = $class->getName();
}
}
return $this->typeHint;
}
private function getType(\ReflectionParameter $param)
{
if ($param->getClass() && $param->getClass()->getName()) {
return $param->getClass()->getName();
}
if ($param->isArray()) {
return 'Array';
}
}
public function validate(\ReflectionParameter $parameter, $argument)
{
if ($parameter->isArray()) {
$this->validateArrayArgument($argument);
} elseif ($parameter->getClass()) {
$this->validateObjectArgument($parameter->getClass()->getName(), $argument, $parameter->allowsNull());
}
// other arguments don't need to be or can't be validated
}
/**
* @param Horde_Injector $injector
* @param ReflectionParameter $method
*
* @return mixed
* @throws Horde_Injector_Exception
*/
public function getParameterDependency(Horde_Injector $injector, ReflectionParameter $parameter)
{
if ($parameter->getClass()) {
return $injector->getInstance($parameter->getClass()->getName());
} elseif ($parameter->isOptional()) {
return $parameter->getDefaultValue();
}
throw new Horde_Injector_Exception("Untyped parameter \$" . $parameter->getName() . "can't be fulfilled");
}
/**
* @param \ReflectionParameter $reflectionParameter
*
* @return null|string
*/
protected function getTypeByReflectionParameter(\ReflectionParameter $reflectionParameter)
{
if ($reflectionParameter->getClass()) {
return $reflectionParameter->getClass()->getName();
}
if ($reflectionParameter->isArray()) {
return 'array';
}
return null;
}
private function getArgument(\ReflectionParameter $argument)
{
if ($argument->isOptional()) {
return $argument->getDefaultValue();
}
if ($argument->allowsNull()) {
return null;
}
if ($argument->getClass()) {
return $this->getMockBuilder($argument->getClass()->getName())->disableOriginalConstructor()->getMock();
}
return null;
}
public function exportCode()
{
$default_value = null;
if ($this->_parameter->isDefaultValueAvailable()) {
$default_value = $this->_parameter->getDefaultValue();
if (is_scalar($default_value) && !is_numeric($default_value)) {
$default_value = "'{$default_value}'";
}
} elseif ($this->_parameter->isOptional()) {
$default_value = 'NULL';
}
return sprintf('%s%s$%s%s', $this->_parameter->getClass() ? "{$this->_parameter->getClass()->getName()} " : '', $this->_parameter->isPassedByReference() ? '&' : '', $this->_parameter->getName(), $default_value ? " = {$default_value}" : '');
}
private static function loadArray($object, &$result, $prefix = "")
{
$reflect = new ReflectionClass($object);
$typeName = $reflect->getName();
$properties = ObjectParser::getProperties($object);
if (is_array($properties)) {
foreach ($properties as $key => $prop) {
$propertyName = $prop->getName();
$propNameCamelCase = ucfirst($propertyName);
$getMethodName = "get{$propNameCamelCase}";
$setMethodName = "set{$propNameCamelCase}";
$setIdMethodName = "{$setMethodName}_id";
$setMethodParameter = new ReflectionParameter(array($typeName, $setMethodName), 0);
if ($reflect->getMethod($setMethodName) && $setMethodParameter->getClass() && method_exists($object, $setIdMethodName)) {
continue;
}
$value = $object->{$getMethodName}();
$name = $prefix . $propertyName;
if (is_object($value)) {
ObjectParser::loadArray($value, $result, "{$name}.");
} else {
$result[$name] = $value;
}
}
return true;
}
return false;
}
public function getParamTypeHint(\ReflectionFunctionAbstract $function, \ReflectionParameter $param)
{
$lowParam = strtolower($param->name);
if ($function instanceof \ReflectionMethod) {
$lowClass = strtolower($function->class);
$lowMethod = strtolower($function->name);
$paramCacheKey = self::CACHE_KEY_CLASSES . "{$lowClass}.{$lowMethod}.param-{$lowParam}";
} else {
$lowFunc = strtolower($function->name);
$paramCacheKey = $lowFunc !== '{closure}' ? self::CACHE_KEY_FUNCS . ".{$lowFunc}.param-{$lowParam}" : null;
}
$typeHint = $paramCacheKey === null ? false : $this->cache->fetch($paramCacheKey);
if (false !== $typeHint) {
return $typeHint;
}
if ($reflectionClass = $param->getClass()) {
$typeHint = $reflectionClass->getName();
$classCacheKey = self::CACHE_KEY_CLASSES . strtolower($typeHint);
$this->cache->store($classCacheKey, $reflectionClass);
} else {
$typeHint = null;
}
$this->cache->store($paramCacheKey, $typeHint);
return $typeHint;
}
public function __construct(ReflectionParameter $param)
{
if (method_exists('ReflectionParameter', 'getType')) {
if ($type = $param->getType()) {
$this->type_hint = (string) $type;
}
} else {
if ($param->isArray()) {
$this->type_hint = 'array';
} else {
try {
if ($this->type_hint = $param->getClass()) {
$this->type_hint = $this->type_hint->name;
}
} catch (ReflectionException $e) {
preg_match('/\\[\\s\\<\\w+?>\\s([\\w]+)/s', $param->__toString(), $matches);
$this->type_hint = isset($matches[1]) ? $matches[1] : '';
}
}
}
$this->reference = $param->isPassedByReference();
$this->position = $param->getPosition();
$this->name = $param->getName();
if ($param->isDefaultValueAvailable()) {
$this->default = var_export($param->getDefaultValue(), true);
}
}
private function generateTypeHint(\ReflectionParameter $param)
{
if ($param->isArray()) {
return 'array ';
} else {
if ($param->isCallable()) {
return 'callable ';
} else {
if ($param->getClass()) {
return $param->getClass()->getName() . ' ';
} else {
return '';
}
}
}
}
public function getClass()
{
$phpReflection = parent::getClass();
$zendReflection = new ZendL_Reflection_Class($phpReflection->getName());
unset($phpReflection);
return $zendReflection;
}
/**
* Gets the argument value for a parameter.
*
* @param \ReflectionParameter $parameter
* The parameter of a callable to get the value for.
*
* @return mixed
* The value of the requested parameter value.
*
* @throws \RuntimeException
* Thrown when there is a missing parameter.
*/
protected function getArgument(\ReflectionParameter $parameter)
{
$parameter_type_hint = $parameter->getClass();
$parameter_name = $parameter->getName();
// If the argument exists and is NULL, return it, regardless of
// parameter type hint.
if (!isset($this->objects[$parameter_name]) && array_key_exists($parameter_name, $this->objects)) {
return NULL;
}
if ($parameter_type_hint) {
// If the argument exists and complies with the type hint, return it.
if (isset($this->objects[$parameter_name]) && is_object($this->objects[$parameter_name]) && $parameter_type_hint->isInstance($this->objects[$parameter_name])) {
return $this->objects[$parameter_name];
}
// Otherwise, resolve wildcard arguments by type matching.
foreach ($this->wildcards as $wildcard) {
if ($parameter_type_hint->isInstance($wildcard)) {
return $wildcard;
}
}
} elseif (isset($this->scalars[$parameter_name])) {
return $this->scalars[$parameter_name];
}
// If the callable provides a default value, use it.
if ($parameter->isDefaultValueAvailable()) {
return $parameter->getDefaultValue();
}
// Can't resolve it: call a method that throws an exception or can be
// overridden to do something else.
return $this->handleUnresolvedArgument($parameter);
}
/**
* Creates a PHP parameter from reflection
*
* @param \ReflectionParameter $ref
* @return PhpParameter
*/
public static function fromReflection(\ReflectionParameter $ref)
{
$parameter = new static();
$parameter->setName($ref->name)->setPassedByReference($ref->isPassedByReference());
if ($ref->isDefaultValueAvailable()) {
$parameter->setDefaultValue($ref->getDefaultValue());
}
// find type and description in docblock
$docblock = new Docblock($ref->getDeclaringFunction());
$params = $docblock->getTags('param');
$tag = $params->find($ref->name, function (ParamTag $t, $name) {
return $t->getVariable() == '$' . $name;
});
if ($tag !== null) {
$parameter->setType($tag->getType(), $tag->getDescription());
}
// set type if not found in comment
if ($parameter->getType() === null) {
if ($ref->isArray()) {
$parameter->setType('array');
} elseif ($class = $ref->getClass()) {
$parameter->setType($class->getName());
} elseif (method_exists($ref, 'isCallable') && $ref->isCallable()) {
$parameter->setType('callable');
}
}
return $parameter;
}
/**
* @param \ReflectionParameter $parameter
* @return mixed
*/
private function loadParameter(\ReflectionParameter $parameter)
{
$class = $parameter->getClass();
if (is_null($class)) {
throw new \Exception('Constructor parameter must be autoloaded but missing parameter type for parameter ' . $parameter->getName());
}
return $this->getSkeleton()->get($class->getName());
}
private static function buildField(\ReflectionParameter $parameter, $data)
{
// If parameter turns out to be an Object then recurse
if (!empty($parameter->getClass())) {
return self::build($parameter->getClass()->getName(), $data);
}
// If parameter is type of array, then check whether it is an array of Object
if ($parameter->isArray()) {
$possibleObjectClassName = $parameter->getDeclaringClass()->getName() . '_' . $parameter->getName() . '_item';
if (class_exists($possibleObjectClassName)) {
return array_map(function ($values) use($possibleObjectClassName) {
return self::build($possibleObjectClassName, $values);
}, $data);
}
}
return $data;
}
/**
* Helper method to get the type of a reflection paramter
* @param \ReflectionParameter $parameter
* @return NULL|\ReflectionType|string
*/
protected function getReflectionParameterName(\ReflectionParameter $parameter)
{
// parameter is a class
if ($class = $parameter->getClass()) {
return $class->getName() . ' \\$' . $parameter->getName();
}
return $parameter->getName();
}
/**
* Returns true if the given controller parameter is type-hinted as an instance of ScopeFetcher.
*
* @param \ReflectionParameter $controllerParam A parameter of the controller action.
*
* @return bool
*/
private function isScopeFetcherType(\ReflectionParameter $controllerParam)
{
$class = $controllerParam->getClass();
if (!$class) {
return false;
}
return $class->implementsInterface(self::SCOPE_FETCHER_INTERFACE);
}
function it_resolves_an_argument_if_it_is_an_element_type(Factory $factory, \ReflectionClass $class, \ReflectionMethod $constructor, \ReflectionParameter $anyParameter, \ReflectionParameter $elementParameter, \ReflectionClass $elementParameterClass, MyElement $element)
{
$constructor->getParameters()->willReturn(array($anyParameter, $elementParameter));
$elementParameter->getClass()->willReturn($elementParameterClass);
$elementParameterClass->getName()->willReturn('spec\\SensioLabs\\Behat\\PageObjectExtension\\Context\\Argument\\MyElement');
$factory->instantiate('spec\\SensioLabs\\Behat\\PageObjectExtension\\Context\\Argument\\MyElement')->willReturn($element);
$this->resolveArguments($class, array())->shouldReturn(array(1 => $element));
}
/**
* Gets a class.
*
* @return \Wingu\OctopusCore\Reflection\ReflectionClass
*/
public function getClass()
{
$class = parent::getClass();
if ($class !== null) {
$class = new ReflectionClass($class->getName());
}
return $class;
}
/**
* Returns the parameter class
*
* @return ClassReflection The parameter class
*/
public function getClass()
{
try {
$class = parent::getClass();
} catch (\Exception $e) {
return NULL;
}
return is_object($class) ? new ClassReflection($class->getName()) : NULL;
}
