/**
* {@inheritdoc}
*/
public function getFunction($name, $namespace = '')
{
$parsedFunctions = $this->parserStorage->getFunctions();
$function = $this->findElementByNameAndNamespace($parsedFunctions, $name, $namespace);
if ($function && $function->isDocumented()) {
return $function;
}
return null;
}
/**
* {@inheritdoc}
*/
public function generate()
{
$template = $this->templateFactory->createForType('tree');
$classes = $this->parserStorage->getClasses();
foreach ($classes as $className => $reflection) {
if ($this->canBeProcessed($reflection)) {
$this->addToTreeByReflection($reflection);
}
}
$this->sortTreeStorageElements();
$template->setParameters(['classTree' => new Tree($this->treeStorage[ElementsInterface::CLASSES], $classes), 'interfaceTree' => new Tree($this->treeStorage[ElementsInterface::INTERFACES], $classes), 'traitTree' => new Tree($this->treeStorage[ElementsInterface::TRAITS], $classes), 'exceptionTree' => new Tree($this->treeStorage[ElementsInterface::EXCEPTIONS], $classes)]);
$template->save();
}
private function categorizeParsedElements()
{
foreach ($this->parserStorage->getTypes() as $type) {
$elements = $this->parserStorage->getElementsByType($type);
foreach ($elements as $elementName => $element) {
if (!$element->isDocumented()) {
continue;
}
if ($element instanceof ConstantReflectionInterface) {
$elementType = Elements::CONSTANTS;
$this->constants[$elementName] = $element;
} elseif ($element instanceof FunctionReflectionInterface) {
$elementType = Elements::FUNCTIONS;
$this->functions[$elementName] = $element;
} elseif ($element->isInterface()) {
$elementType = Elements::INTERFACES;
$this->interfaces[$elementName] = $element;
} elseif ($element->isTrait()) {
$elementType = Elements::TRAITS;
$this->traits[$elementName] = $element;
} elseif ($element->isException()) {
$elementType = Elements::EXCEPTIONS;
$this->exceptions[$elementName] = $element;
} else {
$elementType = Elements::CLASSES;
$this->classes[$elementName] = $element;
}
$this->categorizeElementToNamespaceAndPackage($elementName, $elementType, $element);
}
}
$this->sortNamespacesAndPackages();
$this->areElementsCategorized = true;
$this->addUsedByAnnotation();
}
private function scanAndParse(array $options)
{
$this->io->writeln('<info>Scanning sources and parsing</info>');
$files = $this->finder->find($options['source'], $options['exclude'], $options['extensions']);
$this->parser->parse($files);
$this->reportParserErrors($this->parser->getErrors());
$stats = $this->parserResult->getDocumentedStats();
$this->io->writeln(sprintf('Found <comment>%d classes</comment>, <comment>%d constants</comment> and <comment>%d functions</comment>', $stats['classes'], $stats['constants'], $stats['functions']));
}
private function loadToParserResult(ArrayObject $classes, ArrayObject $constants, ArrayObject $functions, ArrayObject $internalClasses, ArrayObject $tokenizedClasses)
{
$this->parserStorage->setClasses($classes);
$this->parserStorage->setConstants($constants);
$this->parserStorage->setFunctions($functions);
$this->parserStorage->setInternalClasses($internalClasses);
$this->parserStorage->setTokenizedClasses($tokenizedClasses);
}
/**
* @return ClassReflectionInterface[]
*/
public function getParsedClasses()
{
return $this->parserResult->getElementsByType(ElementsInterface::CLASSES);
}
