public function testDocblockTags() { $classReflection = new ClassReflection('ZendTest\\Code\\Reflection\\TestAsset\\TestSampleClass5'); $this->assertEquals(1, count($classReflection->getDocblock()->getTags())); $this->assertEquals(1, count($classReflection->getDocblock()->getTags('author'))); $this->assertFalse($classReflection->getDocblock()->getTag('version')); $this->assertTrue($classReflection->getMethod('doSomething')->getDocblock()->hasTag('return')); $returnTag = $classReflection->getMethod('doSomething')->getDocblock()->getTag('return'); $this->assertInstanceOf('Zend\\Code\\Reflection\\DocBlock\\Tag', $returnTag); $this->assertEquals('mixed', $returnTag->getType()); }
/** * Converts the provided input array from key-value format to a list of parameters suitable for the specified * class / method. * * The input array should have the field name as the key, and the value will either be a primitive or another * key-value array. The top level of this array needs keys that match the names of the parameters on the * service method. * * Mismatched types are caught by the PHP runtime, not explicitly checked for by this code. * * @param string $serviceClassName name of the service class that we are trying to call * @param string $serviceMethodName name of the method that we are trying to call * @param array $inputArray data to send to method in key-value format * @return array list of parameters that can be used to call the service method */ public function getInputData($serviceClassName, $serviceMethodName, array $inputArray) { /** TODO: Reflection causes performance degradation when used in runtime. Should be optimized via caching */ $serviceClass = new ClassReflection($serviceClassName); /** @var MethodReflection $serviceMethod */ $serviceMethod = $serviceClass->getMethod($serviceMethodName); /** @var ParameterReflection[] $params */ $params = $serviceMethod->getParameters(); $inputData = []; foreach ($params as $param) { $paramName = $param->getName(); $snakeCaseParamName = strtolower(preg_replace("/(?<=\\w)(?=[A-Z])/", "_\$1", $paramName)); if (isset($inputArray[$paramName]) || isset($inputArray[$snakeCaseParamName])) { $paramValue = isset($inputArray[$paramName]) ? $inputArray[$paramName] : $inputArray[$snakeCaseParamName]; if ($this->_isArrayParam($param)) { $paramType = "{$param->getType()}[]"; } else { $paramType = $param->getType(); } $inputData[] = $this->_convertValue($paramValue, $paramType); } else { $inputData[] = $param->isDefaultValueAvailable() ? $param->getDefaultValue() : null; } } return $inputData; }
/** * @group prototype */ public function testCorrectlyBuildsArgumentPrototypeContainingClassNames() { $r = $this->class->getMethod('action2'); $method = new ClassMethod($r); $this->assertEquals('null|Zend\Loader\PluginClassLoader $loader', $method->getPrototype()); }
public function testMethodReturns() { $reflectionClass = new ClassReflection('ZendTest\\Code\\Reflection\\TestAsset\\TestSampleClass2'); $methodByName = $reflectionClass->getMethod('getProp1'); $this->assertEquals('Zend\\Code\\Reflection\\MethodReflection', get_class($methodByName)); $methodsAll = $reflectionClass->getMethods(); $this->assertEquals(3, count($methodsAll)); $firstMethod = array_shift($methodsAll); $this->assertEquals('getProp1', $firstMethod->getName()); }
/** * @return AnnotationCollection */ public function getAnnotations() { $reflection = new ClassReflection($this->getObject()); try { $reflectionMethod = $reflection->getMethod($this->getMethod()); return $reflectionMethod->getAnnotations($this->getAnnotationManager()); } catch (\ReflectionException $e) { return false; } }
/** * Get forms for a module * * @param $moduleObject * * @return array */ protected function loadPluginsForModule($moduleObject) { // initialize plugins $plugins = array(); // check for configuration if (!method_exists($moduleObject, 'getConfig')) { return $plugins; } // get module configuration $moduleConfig = $moduleObject->getConfig(); // check for no configured plugins if (!isset($moduleConfig['controller_plugins'])) { return $plugins; } // loop through plugins foreach ($moduleConfig['controller_plugins'] as $type => $loadedPlugins) { // skip if not invokable nor factory if (!in_array($type, array('invokables', 'factories'))) { continue; } // initialize plugin type $plugins[$type] = array(); // loop through plugin list foreach ($loadedPlugins as $pluginKey => $pluginClass) { // check if plugin class or factory does not exist if (!class_exists($pluginClass)) { continue; } // check for factory if (in_array('Zend\\ServiceManager\\FactoryInterface', class_implements($pluginClass))) { // start class reflection $classReflection = new ClassReflection($pluginClass); // get create method and doc block $method = $classReflection->getMethod('createService'); $docBlock = $method->getDocBlock(); // check doc block for return tag and use class if ($docBlock) { // loop through all doc blocks foreach ($docBlock->getTags() as $tag) { /** @var $tag ReturnTag */ if ($tag->getName() != 'return') { continue; } $pluginClass = $classReflection->getNamespaceName() . '\\' . $tag->getTypes()[0]; } } else { // try to read plugin instantiation from method preg_match_all('^\\$plugin\\s*=\\s*new\\s*([a-zA-z0-9]+)\\(\\)\\;^', $method->getContents(), $matches); $pluginClass = $classReflection->getNamespaceName() . '\\' . $matches[1][0]; } } // check for class existence if (!class_exists($pluginClass)) { break; } // add plugin class for type $plugins[$type][$pluginKey] = $pluginClass; } } // loop through plugins foreach ($plugins as $type => $pluginList) { // check if any plugin exists for type if (empty($pluginList)) { unset($plugins[$type]); // otherwise sort plugins } else { ksort($plugins[$type]); } } return $plugins; }
/** * Checks if method is defined * * Case sensitivity of the method is taken into account. * * @param ClassReflection $class * @param string $methodName * @return bool */ protected function classHasMethod(ClassReflection $class, $methodName) { return $class->hasMethod($methodName) && $class->getMethod($methodName)->getName() == $methodName; }
public function testGetParameterDescription() { $class = new ClassReflection("\\Magento\\Framework\\Reflection\\Test\\Unit\\DataObject"); $methodReflection = $class->getMethod('setName'); $paramsReflection = $methodReflection->getParameters(); $this->assertEquals('Name of the attribute', $this->_typeProcessor->getParamDescription($paramsReflection[0])); }
/** * Retrieve requested service method params metadata. * * @param string $serviceClassName * @param string $serviceMethodName * @return array */ protected function getMethodParams($serviceClassName, $serviceMethodName) { $cacheId = self::CACHE_ID_PREFIX . hash('md5', $serviceClassName . $serviceMethodName); $params = $this->cache->load($cacheId); if ($params !== false) { return unserialize($params); } $serviceClass = new ClassReflection($serviceClassName); /** @var MethodReflection $serviceMethod */ $serviceMethod = $serviceClass->getMethod($serviceMethodName); $params = []; /** @var ParameterReflection $paramReflection */ foreach ($serviceMethod->getParameters() as $paramReflection) { $isDefaultValueAvailable = $paramReflection->isDefaultValueAvailable(); $params[] = [ 'name' => $paramReflection->getName(), 'type' => $this->typeProcessor->getParamType($paramReflection), 'isDefaultValueAvailable' => $isDefaultValueAvailable, 'defaultValue' => $isDefaultValueAvailable ? $paramReflection->getDefaultValue() : null ]; } $this->cache->save(serialize($params), $cacheId, [WebapiCache::CACHE_TAG]); return $params; }
public function testAutodetectAction() { $configBuilder = new RouteConfigBuilder(); /* @var $parser ControllerAnnotationParser */ $parser = $this->serviceManager->get('parser'); $classReflection = new ClassReflection(new NoBaseController()); $method = $classReflection->getMethod('noActionAction'); $annotations = $parser->getMethodAnnotations($method); /* @var $route Route */ $route = $annotations[0]; $parser->autodetectMissingFields($route, $method, 'controllerkey'); $configBuilder->addPart($route); $routeArray = array('no-action' => array('type' => 'literal', 'options' => array('route' => '/no-action', 'defaults' => array('controller' => 'controllerkey', 'action' => 'no-action'), 'constraints' => null), 'may_terminate' => true)); $this->assertEquals($routeArray, $configBuilder->toArray()); }
/** * Retrieve requested service method params metadata. * * @param string $serviceClassName * @param string $serviceMethodName * @return array */ public function getMethodParams($serviceClassName, $serviceMethodName) { $cacheId = self::SERVICE_METHOD_PARAMS_CACHE_PREFIX . hash('md5', $serviceClassName . $serviceMethodName); $params = $this->cache->load($cacheId); if ($params !== false) { return unserialize($params); } $serviceClass = new ClassReflection($serviceClassName); /** @var MethodReflection $serviceMethod */ $serviceMethod = $serviceClass->getMethod($serviceMethodName); $params = []; /** @var ParameterReflection $paramReflection */ foreach ($serviceMethod->getParameters() as $paramReflection) { $isDefaultValueAvailable = $paramReflection->isDefaultValueAvailable(); $params[] = [self::METHOD_META_NAME => $paramReflection->getName(), self::METHOD_META_TYPE => $this->typeProcessor->getParamType($paramReflection), self::METHOD_META_HAS_DEFAULT_VALUE => $isDefaultValueAvailable, self::METHOD_META_DEFAULT_VALUE => $isDefaultValueAvailable ? $paramReflection->getDefaultValue() : null]; } $this->cache->save(serialize($params), $cacheId, [ReflectionCache::CACHE_TAG]); return $params; }
/** * @group ZF-8307 */ public function testReturnClassWithNamespace() { $classReflection = new Reflection\ClassReflection('ZendTest\Code\Reflection\TestAsset\TestSampleClass7'); $paramTag = $classReflection->getMethod('doSomething')->getDocBlock()->getTag('return'); $this->assertEquals('Zend\Code\Reflection\DocBlock', $paramTag->getType()); }
/** * Create a new subclass and factory to override a factory-generated * service. * * @param mixed $factory Factory configuration for class to extend * @param string $module Module in which to create the new factory * * @return string * @throws \Exception */ protected function cloneFactory($factory, $module) { // Make sure we can figure out how to handle the factory; it should // either be a [controller, method] array or a "controller::method" // string; anything else will cause a problem. $parts = is_string($factory) ? explode('::', $factory) : $factory; if (!is_array($parts) || count($parts) != 2 || !class_exists($parts[0]) || !method_exists($parts[0], $parts[1])) { throw new \Exception('Unexpected factory configuration format.'); } list($factoryClass, $factoryMethod) = $parts; $newFactoryClass = $this->generateLocalClassName($factoryClass, $module); if (!class_exists($newFactoryClass)) { $this->createClassInModule($newFactoryClass, $module); $skipBackup = true; } else { $skipBackup = false; } if (method_exists($newFactoryClass, $factoryMethod)) { throw new \Exception("{$newFactoryClass}::{$factoryMethod} already exists."); } $oldReflection = new ClassReflection($factoryClass); $newReflection = new ClassReflection($newFactoryClass); $generator = ClassGenerator::fromReflection($newReflection); $method = MethodGenerator::fromReflection($oldReflection->getMethod($factoryMethod)); $this->createServiceClassAndUpdateFactory($method, $oldReflection->getNamespaceName(), $module); $generator->addMethodFromGenerator($method); $this->writeClass($generator, $module, true, $skipBackup); return $newFactoryClass . '::' . $factoryMethod; }
/** * Checks if method is defined * * Case sensitivity of the method is taken into account. * * @param ClassReflection $class * @param string $methodName * @return bool */ public function hasMethod(ClassReflection $class, $methodName) { return $class->hasMethod($methodName) && $class->getMethod($methodName)->getName() == $methodName; }