/**
* 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 : '');
}
