/** * Returns if the class should be documented. * * @return boolean */ public function isDocumented() { if (null === $this->isDocumented && parent::isDocumented()) { $fileName = self::$generator->unPharPath($this->reflection->getFilename()); foreach (self::$config->skipDocPath as $mask) { if (fnmatch($mask, $fileName, FNM_NOESCAPE)) { $this->isDocumented = false; break; } } if (true === $this->isDocumented) { foreach (self::$config->skipDocPrefix as $prefix) { if (0 === strpos($this->reflection->getName(), $prefix)) { $this->isDocumented = false; break; } } } } return $this->isDocumented; }
/** * Tries to parse a definition of a class/method/property/constant/function and returns the appropriate instance if successful. * * @param string $definition Definition * @param \ApiGen\ReflectionElement|\ApiGen\ReflectionParameter $context Link context * @param string $expectedName Expected element name * @return \ApiGen\Reflection\ReflectionElement|null */ public function resolveElement($definition, $context, &$expectedName = null) { // No simple type resolving static $types = array('boolean' => 1, 'integer' => 1, 'float' => 1, 'string' => 1, 'array' => 1, 'object' => 1, 'resource' => 1, 'callback' => 1, 'callable' => 1, 'null' => 1, 'false' => 1, 'true' => 1, 'mixed' => 1); if (empty($definition) || isset($types[$definition])) { return null; } $originalContext = $context; if ($context instanceof Reflection\ReflectionParameter && null === $context->getDeclaringClassName()) { // Parameter of function in namespace or global space $context = $this->getFunction($context->getDeclaringFunctionName()); } elseif ($context instanceof Reflection\ReflectionMethod || $context instanceof Reflection\ReflectionParameter || $context instanceof Reflection\ReflectionConstant && null !== $context->getDeclaringClassName() || $context instanceof Reflection\ReflectionProperty) { // Member of a class $context = $this->getClass($context->getDeclaringClassName()); } if (null === $context) { return null; } // self, $this references if ('self' === $definition || '$this' === $definition) { return $context instanceof ReflectionClass ? $context : null; } $definitionBase = substr($definition, 0, strcspn($definition, '\\:')); $namespaceAliases = $context->getNamespaceAliases(); if (!empty($definitionBase) && isset($namespaceAliases[$definitionBase]) && $definition !== ($className = \TokenReflection\Resolver::resolveClassFQN($definition, $namespaceAliases, $context->getNamespaceName()))) { // Aliased class $expectedName = $className; if (false === strpos($className, ':')) { return $this->getClass($className, $context->getNamespaceName()); } else { $definition = $className; } } elseif ($class = $this->getClass($definition, $context->getNamespaceName())) { // Class return $class; } elseif ($constant = $this->getConstant($definition, $context->getNamespaceName())) { // Constant return $constant; } elseif (($function = $this->getFunction($definition, $context->getNamespaceName())) || '()' === substr($definition, -2) && ($function = $this->getFunction(substr($definition, 0, -2), $context->getNamespaceName()))) { // Function return $function; } if (($pos = strpos($definition, '::')) || ($pos = strpos($definition, '->'))) { // Class::something or Class->something if (0 === strpos($definition, 'parent::') && ($parentClassName = $context->getParentClassName())) { $context = $this->getClass($parentClassName); } elseif (0 !== strpos($definition, 'self::')) { $class = $this->getClass(substr($definition, 0, $pos), $context->getNamespaceName()); if (null === $class) { $class = $this->getClass(\TokenReflection\Resolver::resolveClassFQN(substr($definition, 0, $pos), $context->getNamespaceAliases(), $context->getNamespaceName())); } $context = $class; } $definition = substr($definition, $pos + 2); } elseif ($originalContext instanceof Reflection\ReflectionParameter) { return null; } // No usable context if (null === $context || $context instanceof Reflection\ReflectionConstant || $context instanceof Reflection\ReflectionFunction) { return null; } if ($context->hasProperty($definition)) { // Class property return $context->getProperty($definition); } elseif ('$' === $definition[0] && $context->hasProperty(substr($definition, 1))) { // Class $property return $context->getProperty(substr($definition, 1)); } elseif ($context->hasMethod($definition)) { // Class method return $context->getMethod($definition); } elseif ('()' === substr($definition, -2) && $context->hasMethod(substr($definition, 0, -2))) { // Class method() return $context->getMethod(substr($definition, 0, -2)); } elseif ($context->hasConstant($definition)) { // Class constant return $context->getConstant($definition); } return null; }
/** * Returns a link to a element source code. * * @param \ApiGen\ReflectionElement $element Element reflection * @param boolean $withLine Include file line number into the link * * @return string */ public function getSourceUrl(ReflectionElement $element, $withLine = true) { if ($element instanceof ReflectionClass || $element instanceof ReflectionFunction || $element instanceof ReflectionConstant && null === $element->getDeclaringClassName()) { $elementName = $element->getName(); if ($element instanceof ReflectionClass) { $file = 'class-'; } elseif ($element instanceof ReflectionConstant) { $file = 'constant-'; } elseif ($element instanceof ReflectionFunction) { $file = 'function-'; } } else { $elementName = $element->getDeclaringClassName(); $file = 'class-'; } $file .= $this->urlize($elementName); $lines = null; if ($withLine) { $lines = $element->getStartLine() !== $element->getEndLine() ? sprintf('%s-%s', $element->getStartLine(), $element->getEndLine()) : $element->getStartLine(); } return sprintf($this->config->template['templates']['main']['source']['filename'], $file) . (null !== $lines ? '#' . $lines : ''); }