/** * @param MethodReflection $reflectionMethod * @return MethodGenerator */ public static function fromReflection(MethodReflection $reflectionMethod) { $method = new static(); $declaringClass = $reflectionMethod->getDeclaringClass(); $method->setSourceContent($reflectionMethod->getContents(false)); $method->setSourceDirty(false); $method->setReturnType(self::extractReturnTypeFromMethodReflection($reflectionMethod)); if ($reflectionMethod->getDocComment() != '') { $method->setDocBlock(DocBlockGenerator::fromReflection($reflectionMethod->getDocBlock())); } $method->setFinal($reflectionMethod->isFinal()); if ($reflectionMethod->isPrivate()) { $method->setVisibility(self::VISIBILITY_PRIVATE); } elseif ($reflectionMethod->isProtected()) { $method->setVisibility(self::VISIBILITY_PROTECTED); } else { $method->setVisibility(self::VISIBILITY_PUBLIC); } $method->setInterface($declaringClass->isInterface()); $method->setStatic($reflectionMethod->isStatic()); $method->setReturnsReference($reflectionMethod->returnsReference()); $method->setName($reflectionMethod->getName()); foreach ($reflectionMethod->getParameters() as $reflectionParameter) { $method->setParameter(ParameterGenerator::fromReflection($reflectionParameter)); } $method->setBody(static::clearBodyIndention($reflectionMethod->getBody())); return $method; }
/** * fromReflection() * * @param MethodReflection $reflectionMethod * @return MethodGenerator */ public static function fromReflection(MethodReflection $reflectionMethod) { $method = new self(); $method->setSourceContent($reflectionMethod->getContents(false)); $method->setSourceDirty(false); if ($reflectionMethod->getDocComment() != '') { $method->setDocBlock(DocBlockGenerator::fromReflection($reflectionMethod->getDocBlock())); } $method->setFinal($reflectionMethod->isFinal()); if ($reflectionMethod->isPrivate()) { $method->setVisibility(self::VISIBILITY_PRIVATE); } elseif ($reflectionMethod->isProtected()) { $method->setVisibility(self::VISIBILITY_PROTECTED); } else { $method->setVisibility(self::VISIBILITY_PUBLIC); } $method->setStatic($reflectionMethod->isStatic()); $method->setName($reflectionMethod->getName()); foreach ($reflectionMethod->getParameters() as $reflectionParameter) { $method->setParameter(ParameterGenerator::fromReflection($reflectionParameter)); } $method->setBody($reflectionMethod->getBody()); return $method; }
/** @inheritdoc */ protected function _processMethod(\Zend\Code\Reflection\MethodReflection $methodReflection, $typeName) { /* skip basic methods of the DataObjects */ $name = $methodReflection->getName(); if ($name != self::SKIP_DATA && $name != self::SKIP_ITERATOR && $name != self::SKIP_DATA_UNSET) { parent::_processMethod($methodReflection, $typeName); } }
/** * Retrieves the visibility for the given method reflection * * @param MethodReflection $reflectionMethod * * @return string */ private static function extractVisibility(MethodReflection $reflectionMethod) { if ($reflectionMethod->isPrivate()) { return static::VISIBILITY_PRIVATE; } if ($reflectionMethod->isProtected()) { return static::VISIBILITY_PROTECTED; } return static::VISIBILITY_PUBLIC; }
/** * Process class method parameters * * @param array $def * @param Zend\Code\Reflection\ClassReflection $rClass * @param Zend\Code\Reflection\MethodReflection $rMethod */ protected function processParams(&$def, Reflection\ClassReflection $rClass, Reflection\MethodReflection $rMethod) { if (count($rMethod->getParameters()) === 0) { return; } parent::processParams($def, $rClass, $rMethod); $methodName = $rMethod->getName(); /** @var $p \ReflectionParameter */ foreach ($rMethod->getParameters() as $p) { $fqName = $rClass->getName() . '::' . $rMethod->getName() . ':' . $p->getPosition(); $def['parameters'][$methodName][$fqName][] = $p->isOptional() && $p->isDefaultValueAvailable() ? $p->getDefaultValue() : null; } }
public function getDeclaringClass() { if (!empty($this->declaringClass)) { return $this->declaringClass; } return parent::getDeclaringClass(); }
/** * Process method parameters * * @param array $def * @param Reflection\ClassReflection $rClass * @param Reflection\MethodReflection $rMethod */ protected function processParams(&$def, Reflection\ClassReflection $rClass, Reflection\MethodReflection $rMethod) { if (count($rMethod->getParameters()) === 0) { return; } $methodName = $rMethod->getName(); // @todo annotations here for alternate names? $def['parameters'][$methodName] = array(); foreach ($rMethod->getParameters() as $p) { /** @var $p \ReflectionParameter */ $actualParamName = $p->getName(); $fqName = $rClass->getName() . '::' . $rMethod->getName() . ':' . $p->getPosition(); $def['parameters'][$methodName][$fqName] = array(); // set the class name, if it exists $def['parameters'][$methodName][$fqName][] = $actualParamName; $def['parameters'][$methodName][$fqName][] = $p->getClass() !== null ? $p->getClass()->getName() : null; $def['parameters'][$methodName][$fqName][] = !$p->isOptional(); $def['parameters'][$methodName][$fqName][] = $p->isOptional() && $p->isDefaultValueAvailable() ? $p->getDefaultValue() : null; } }
/** * @return MethodGenerator */ private function generateProxyMethod(\ReflectionMethod $method, $preSource, $postSource, $exceptionSource) { $methodReflection = new MethodReflection($method->getDeclaringClass()->getName(), $method->getName()); if ('__construct' === $methodReflection->getName()) { $methodGenerator = MethodGenerator::fromArray(['name' => $methodReflection->getName(), 'body' => '']); } else { $methodGenerator = MethodGenerator::fromReflection($methodReflection); $parametersString = '('; $i = count($method->getParameters()); foreach ($method->getParameters() as $parameter) { $parametersString .= '$' . $parameter->getName() . (--$i > 0 ? ',' : ''); } $parametersString .= ')'; if ('' === $preSource && '' === $postSource && '' === $exceptionSource) { $body = 'return $this->proxy_realSubject->' . $method->getName() . $parametersString . ";\n"; } else { $body = "try {\n" . $preSource . "\n" . '$data = $this->proxy_realSubject->' . $method->getName() . $parametersString . ";\n" . $postSource . "\n" . "return \$data;\n" . "} catch(\\Exception \$e){\n" . $exceptionSource . "\n" . "throw \$e;\n" . '};'; } $methodGenerator->setBody($body); } return $methodGenerator; }
/** * Get parameter annotations from DocBlock * * @return \Zend\Code\Reflection\DocBlock\ParamTag[] */ protected function getParameterTags() { if (null !== $this->parameterAnnotations) { return $this->parameterAnnotations; } $rDocBlock = $this->reflection->getDocBlock(); if ($rDocBlock instanceof DocBlockReflection) { $params = $rDocBlock->getTags('param'); } else { $params = array(); } $this->parameterAnnotations = $params; return $this->parameterAnnotations; }
/** * Retrieve method full documentation description. * * @param \Zend\Code\Reflection\MethodReflection $method * @return string */ protected function extractMethodDescription(\Zend\Code\Reflection\MethodReflection $method) { $methodReflection = new MethodReflection($method->getDeclaringClass()->getName(), $method->getName()); $docBlock = $methodReflection->getDocBlock(); if (!$docBlock) { throw new \LogicException('The docBlock of the method ' . $method->getDeclaringClass()->getName() . '::' . $method->getName() . ' is empty.'); } return $this->_typeProcessor->getDescription($docBlock); }
public function testGetContentsReturnsCorrectContent() { $reflectionMethod = new MethodReflection('ZendTest\\Code\\Reflection\\TestAsset\\TestSampleClass5', 'doSomething'); $this->assertEquals(" {\n\n return 'mixedValue';\n\n }\n", $reflectionMethod->getContents(false)); }
/** * Get possible method exceptions * * @param \Zend\Code\Reflection\MethodReflection $methodReflection * @return array */ public function getExceptions($methodReflection) { $exceptions = []; $methodDocBlock = $methodReflection->getDocBlock(); if ($methodDocBlock->hasTag('throws')) { $throwsTypes = $methodDocBlock->getTags('throws'); if (is_array($throwsTypes)) { /** @var $throwsType \Zend\Code\Reflection\DocBlock\Tag\ThrowsTag */ foreach ($throwsTypes as $throwsType) { $exceptions = array_merge($exceptions, $throwsType->getTypes()); } } } return $exceptions; }
/** * Identify getter return type by its reflection. * * @param \Zend\Code\Reflection\MethodReflection $methodReflection * @return array <pre>array( * 'type' => <string>$type, * 'isRequired' => $isRequired, * 'description' => $description * )</pre> * @throws \InvalidArgumentException */ public function getGetterReturnType($methodReflection) { $methodDocBlock = $methodReflection->getDocBlock(); if (!$methodDocBlock) { throw new \InvalidArgumentException( "Each getter must have description with @return annotation. " . "See {$methodReflection->getDeclaringClass()->getName()}::{$methodReflection->getName()}()" ); } $returnAnnotations = $methodDocBlock->getTags('return'); if (empty($returnAnnotations)) { throw new \InvalidArgumentException( "Getter return type must be specified using @return annotation. " . "See {$methodReflection->getDeclaringClass()->getName()}::{$methodReflection->getName()}()" ); } /** @var \Zend\Code\Reflection\DocBlock\Tag\ReturnTag $returnAnnotation */ $returnAnnotation = current($returnAnnotations); $returnType = $returnAnnotation->getType(); /* * Adding this code as a workaround since \Zend\Code\Reflection\DocBlock\Tag\ReturnTag::initialize does not * detect and return correct type for array of objects in annotation. * eg @return \Magento\Webapi\Service\Entity\SimpleData[] is returned with type * \Magento\Webapi\Service\Entity\SimpleData instead of \Magento\Webapi\Service\Entity\SimpleData[] */ $escapedReturnType = str_replace('[]', '\[\]', $returnType); $escapedReturnType = str_replace('\\', '\\\\', $escapedReturnType); if (preg_match("/.*\\@return\\s+({$escapedReturnType}).*/i", $methodDocBlock->getContents(), $matches)) { $returnType = $matches[1]; } $isRequired = preg_match("/.*\@return\s+\S+\|null.*/i", $methodDocBlock->getContents(), $matches) ? false : true; return [ 'type' => $returnType, 'isRequired' => $isRequired, 'description' => $returnAnnotation->getDescription(), 'parameterCount' => $methodReflection->getNumberOfRequiredParameters() ]; }
public function testGetContentsReturnsEmptyContentsOnInternalCode() { $reflectionMethod = new MethodReflection('ReflectionClass', 'getName'); $this->assertSame('', $reflectionMethod->getContents()); }
/** * Retrieve method full documentation description. * * @param ReflectionMethod $method * @return string */ protected function extractMethodDescription(ReflectionMethod $method) { $methodReflection = new MethodReflection($method->getDeclaringClass()->getName(), $method->getName()); $docBlock = $methodReflection->getDocBlock(); return $this->_typeProcessor->getDescription($docBlock); }
/** * Tries to guess default values for route if there some missing ones. * * @param Route $annotation * @param MethodReflection $method * @param string $controllerKey * @return Route * @throws Exception */ public function autodetectMissingFields(Route $annotation, $method, $controllerKey) { if ($method instanceof MethodReflection) { $methodName = $method->getName(); } else { if (is_string($method)) { $methodName = $method; } else { throw new Exception('Method must be a string or instance of MethodReflection'); } } if (!$annotation->hasName()) { $annotation->setName($this->filterActionMethodName($methodName)); } if (!$annotation->hasType()) { $annotation->setType('literal'); } if (!$annotation->hasDefaultController()) { $annotation->setDefaultController($controllerKey); } if (!$annotation->hasDefaultAction()) { $annotation->setDefaultAction($this->filterActionMethodName($methodName)); } if (!$annotation->hasRoute()) { $annotation->setRoute('/' . $this->filterActionMethodName($methodName)); } return $annotation; }