/**
* Adds a new method to the class using an array of tokens
*
* @param ClassReflection $class Class reflection
* @param string $methodTag Method tag contents
*
* @return bool
*/
protected function injectMethod(ClassReflection $class, $methodTag)
{
$data = $this->parseMethod($methodTag);
// Bail if the method format is invalid
if (!$data) {
return false;
}
$method = new MethodReflection($data['name'], $class->getLine());
$method->setDocComment($data['description']);
$method->setShortDesc($data['description']);
if ($data['hint']) {
$method->setHint(array(array($data['hint'], null)));
}
// Add arguments to the method
foreach ($data['args'] as $name => $arg) {
$param = new ParameterReflection($name, $class->getLine());
if (!empty($arg['hint'])) {
$param->setHint(array(array($arg['hint'], null)));
}
if (!empty($arg['default'])) {
$param->setDefault($arg['default']);
}
$method->addParameter($param);
}
$class->addMethod($method);
return true;
}
protected function createClasses($interfaceName, $parentName, $className)
{
$interface = new ClassReflection($interfaceName, 1);
$parent = new ClassReflection($parentName, 1);
$parent->addInterface($interfaceName);
$class = new ClassReflection($className, 1);
$class->setParent($parentName);
return array($interfaceName, $parentName, $className, $class, $parent, $interface);
}
public function visit(ClassReflection $class)
{
$filePath = $this->remoteRepository->getRelativePath($class->getFile());
if ('' !== $filePath) {
$class->setRelativeFilePath($filePath);
return true;
}
return false;
}
/**
* Adds a new property to the class using an array of tokens.
*
* @param ClassReflection $class Class reflection
* @param string $propertyTag Property tag contents
*
* @return bool
*/
protected function injectProperty(ClassReflection $class, $propertyTag)
{
if (!($data = $this->parseProperty($propertyTag))) {
return false;
}
$property = new PropertyReflection($data['name'], $class->getLine());
$property->setDocComment($data['description']);
$property->setShortDesc($data['description']);
if (isset($data['hint'])) {
$property->setHint(array(array($data['hint'], null)));
}
$class->addProperty($property);
return true;
}
public function addClass(ClassReflection $class)
{
$name = $class->getName();
$hash = $class->getHash();
if (isset($this->classes[$name])) {
unset($this->hashes[$this->classes[$name]][$name]);
if (!$this->hashes[$this->classes[$name]]) {
unset($this->hashes[$this->classes[$name]]);
}
}
$this->hashes[$hash][$name] = true;
$this->classes[$name] = $hash;
$this->modified[] = $name;
$this->visited[$hash] = true;
}
public function visit(ClassReflection $class)
{
$modified = false;
foreach ($class->getMethods() as $name => $method) {
if (!($parentMethod = $class->getParentMethod($name))) {
continue;
}
foreach ($method->getParameters() as $name => $parameter) {
if (!($parentParameter = $parentMethod->getParameter($name))) {
continue;
}
if ($parameter->getShortDesc() != $parentParameter->getShortDesc()) {
$parameter->setShortDesc($parentParameter->getShortDesc());
$modified = true;
}
if ($parameter->getHint() != $parentParameter->getRawHint()) {
// FIXME: should test for a raw hint from tags, not the one from PHP itself
$parameter->setHint($parentParameter->getRawHint());
$modified = true;
}
}
if ($method->getHint() != $parentMethod->getRawHint()) {
$method->setHint($parentMethod->getRawHint());
$modified = true;
}
if ($method->getHintDesc() != $parentMethod->getHintDesc()) {
$method->setHintDesc($parentMethod->getHintDesc());
$modified = true;
}
if ('{@inheritdoc}' == strtolower(trim($method->getShortDesc())) || !$method->getDocComment()) {
if ($method->getShortDesc() != $parentMethod->getShortDesc()) {
$method->setShortDesc($parentMethod->getShortDesc());
$modified = true;
}
if ($method->getLongDesc() != $parentMethod->getLongDesc()) {
$method->setLongDesc($parentMethod->getLongDesc());
$modified = true;
}
if ($method->getExceptions() != $parentMethod->getRawExceptions()) {
$method->setExceptions($parentMethod->getRawExceptions());
$modified = true;
}
}
}
return $modified;
}
public function readProject(Project $project)
{
$classes = array();
foreach (Finder::create()->name('c_*.json')->in($this->getStoreDir($project)) as $file) {
$classes[] = ClassReflection::fromArray($project, json_decode(file_get_contents($file), true));
}
return $classes;
}
protected function addClassOrInterface($node)
{
$class = new ClassReflection((string) $node->namespacedName, $node->getLine());
$class->setModifiers($node->type);
$class->setNamespace($this->context->getNamespace());
$class->setAliases($this->context->getAliases());
$class->setHash($this->context->getHash());
$class->setFile($this->context->getFile());
if ($this->context->getFilter()->acceptClass($class)) {
$comment = $this->context->getDocBlockParser()->parse($node->getDocComment(), $this->context, $class);
$class->setDocComment($node->getDocComment());
$class->setShortDesc($comment->getShortDesc());
$class->setLongDesc($comment->getLongDesc());
if ($errors = $comment->getErrors()) {
$this->context->addErrors((string) $class, $node->getLine(), $errors);
$class->setErrors($errors);
} else {
$class->setTags($comment->getOtherTags());
}
$this->context->enterClass($class);
}
return $class;
}
public function acceptClass(ClassReflection $class)
{
return $class->getTags('api');
}
public function writeClass(Project $project, ClassReflection $class)
{
$this->classes[$class->getName()] = $class;
}
private function isAnyPropertyAnApi(ClassReflection $class)
{
$rc = new \ReflectionClass($class->getName());
$props = $rc->getProperties();
foreach ($props as $prop) {
$docComment = $prop->getDocComment();
if (false !== strpos($docComment, '@api')) {
return true;
}
}
return false;
}
public function acceptClass(ClassReflection $class)
{
return $class->getDocBlock()->getTag('api');
}
protected function updateCache(ClassReflection $class)
{
$name = $class->getName();
$this->namespaces[$class->getNamespace()] = $class->getNamespace();
// add sub-namespaces
$namespace = $class->getNamespace();
while ($namespace = substr($namespace, 0, strrpos($namespace, '\\'))) {
$this->namespaces[$namespace] = $namespace;
}
if ($class->isException()) {
$this->namespaceExceptions[$class->getNamespace()][$name] = $class;
} elseif ($class->isInterface()) {
$this->namespaceInterfaces[$class->getNamespace()][$name] = $class;
$this->interfaces[$name] = $class;
} else {
$this->namespaceClasses[$class->getNamespace()][$name] = $class;
}
if ($this->getConfig('simulate_namespaces')) {
if (false !== ($pos = strrpos($name, '_'))) {
$this->simulatedNamespaces[$namespace = str_replace('_', '\\', substr($name, 0, $pos))][$name] = $class;
// add sub-namespaces
while ($namespace = substr($namespace, 0, strrpos($namespace, '\\'))) {
if (!isset($this->simulatedNamespaces[$namespace])) {
$this->simulatedNamespaces[$namespace] = array();
}
}
} else {
$this->simulatedNamespaces[''][$name] = $class;
}
}
}
public function removeClass(ClassReflection $class)
{
unset($this->classes[$class->getName()]);
unset($this->interfaces[$class->getName()]);
unset($this->namespaceClasses[$class->getNamespace()][$class->getName()]);
unset($this->namespaceInterfaces[$class->getNamespace()][$class->getName()]);
unset($this->namespaceExceptions[$class->getNamespace()][$class->getName()]);
}
