/**
* Overwrites the type and description in the Argument Descriptor with that from the tag if the names match.
*
* @param ArgumentReflector $argument
* @param ParamDescriptor $paramDescriptor
* @param ArgumentDescriptor $argumentDescriptor
*
* @return void
*/
protected function overwriteTypeAndDescriptionFromParamTag(ArgumentReflector $argument, ParamDescriptor $paramDescriptor, ArgumentDescriptor $argumentDescriptor)
{
if ($paramDescriptor->getVariableName() != $argument->getName()) {
return;
}
$argumentDescriptor->setDescription($paramDescriptor->getDescription());
$argumentDescriptor->setTypes($paramDescriptor->getTypes() ?: $this->builder->buildDescriptor(new Collection(array($argument->getType() ?: 'mixed'))));
}
/**
* Initializes the reflector using the function statement object of
* PHP-Parser.
*
* @param \PHPParser_Node_Stmt $node Function object coming from PHP-Parser.
*/
public function __construct(\PHPParser_Node_Stmt $node)
{
parent::__construct($node);
/** @var \PHPParser_Node_Param $param */
foreach ($node->params as $param) {
$reflector = new FunctionReflector\ArgumentReflector($param);
$this->arguments[$reflector->getName()] = $reflector;
}
}
/**
* Initializes the reflector using the function statement object of
* PHP-Parser.
*
* @param \PhpParser\Node\Stmt $node Function object coming from PHP-Parser.
* @param Context $context The context in which the node occurs.
*/
public function __construct(\PhpParser\Node\Stmt $node, Context $context)
{
parent::__construct($node, $context);
/** @var \PhpParser\Node\Param $param */
foreach ($node->params as $param) {
$reflector = new FunctionReflector\ArgumentReflector($param, $context);
$this->arguments[$reflector->getName()] = $reflector;
}
}
/**
* Exports the given reflection object to the parent XML element.
*
* This method creates a new child element on the given parent XML element
* and takes the properties of the Reflection argument and sets the
* elements and attributes on the child.
*
* If a child DOMElement is provided then the properties and attributes are
* set on this but the child element is not appended onto the parent. This
* is the responsibility of the invoker. Essentially this means that the
* $parent argument is ignored in this case.
*
* @param \DOMElement $parent The parent element to augment.
* @param ArgumentReflector $argument The data source.
* @param \DOMElement $child Optional: child element to use instead
* of creating a new one on the $parent.
*
* @return void
*/
public function export(\DOMElement $parent, $argument, \DOMElement $child = null)
{
if (!$child) {
$child = new \DOMElement('argument');
$parent->appendChild($child);
}
$child->setAttribute('line', $argument->getLineNumber());
$child->appendChild(new \DOMElement('name', $argument->getName()));
$child->appendChild(new \DOMElement('default'))->appendChild(new \DOMText($argument->getDefault()));
$type = $argument->getType();
$child->appendChild(new \DOMElement('type', $type ? $type : ''));
}
/**
* Exports the given reflection object to the parent XML element.
*
* This method creates a new child element on the given parent XML element
* and takes the properties of the Reflection argument and sets the
* elements and attributes on the child.
*
* If a child DOMElement is provided then the properties and attributes are
* set on this but the child element is not appended onto the parent. This
* is the responsibility of the invoker. Essentially this means that the
* $parent argument is ignored in this case.
*
* @param \DOMElement $parent The parent element to
* augment.
* @param \phpDocumentor\Reflection\FunctionReflector\ArgumentReflector $argument The data source.
* @param \DOMElement $child Optional: child
* element to use instead of creating a new one on the $parent.
*
* @return void
*/
public function export(\DOMElement $parent, $argument, \DOMElement $child = null)
{
if (!$child) {
$child = new \DOMElement('argument');
$parent->appendChild($child);
}
$child->setAttribute('line', $argument->getLineNumber());
$child->appendChild(new \DOMElement('name', $argument->getName()));
$default = new \DOMElement('default');
$child->appendChild($default);
/** @var \DOMDocument $dom_document */
$dom_document = $child->ownerDocument;
$default->appendChild($dom_document->createCDATASection($argument->getDefault()));
$child->appendChild(new \DOMElement('type', $argument->getType()));
}
/**
* @param \phpDocumentor\Reflection\FunctionReflector\ArgumentReflector $reflector
* @param Context $context
* @param array $config
*/
public function __construct($reflector = null, $context = null, $config = [])
{
parent::__construct($config);
if ($reflector === null) {
return;
}
$this->name = $reflector->getName();
$this->typeHint = $reflector->getType();
$this->isOptional = $reflector->getDefault() !== null;
// bypass $reflector->getDefault() for short array syntax
if ($reflector->getNode()->default) {
$this->defaultValue = PrettyPrinter::getRepresentationOfValue($reflector->getNode()->default);
}
$this->isPassedByReference = $reflector->isByRef();
}
/**
* Creates a Descriptor from the provided data.
*
* @param ArgumentReflector $data
* @param ParamDescriptor[] $params
*
* @return ArgumentDescriptor
*/
public function create($data, $params = array())
{
$argumentDescriptor = new ArgumentDescriptor();
$argumentDescriptor->setName($data->getName());
$argumentDescriptor->setTypes($data->getType() ? array($data->getType()) : array());
/** @var ParamDescriptor $tag */
foreach ($params as $tag) {
if ($tag->getVariableName() == $data->getName()) {
$argumentDescriptor->setDescription($tag->getDescription());
$types = $tag->getTypes() ?: array($data->getType() ?: 'mixed');
$argumentDescriptor->setTypes($types);
}
}
$argumentDescriptor->setDefault($data->getDefault());
return $argumentDescriptor;
}
/**
* Checks the typehint of the argument versus the @param tag.
*
* If the argument has no typehint we do not check anything. When multiple
* type are given then the typehint needs to be one of them.
*
* @param \phpDocumentor\Reflection\DocBlock\Tag\ParamTag $param
* @param \phpDocumentor\Reflection\FunctionReflector\ArgumentReflector $argument
*
* @return bool whether an issue occurred
*/
protected function doesArgumentTypehintMatchParam(\phpDocumentor\Reflection\DocBlock\Tag\ParamTag $param, \phpDocumentor\Reflection\FunctionReflector\ArgumentReflector $argument)
{
if (!$argument->getType() || in_array($argument->getType(), $param->getTypes())) {
return true;
}
$this->logParserError('ERROR', 50016, $this->lineNumber, array($argument->getName(), $this->entityName . '()'));
return false;
}
/**
* Checks the typehint of the argument versus the @param tag.
*
* If the argument has no typehint we do not check anything. When multiple
* type are given then the typehint needs to be one of them.
*
* @param ParamTag $param
* @param ArgumentReflector $argument
*
* @return Error|null
*/
protected function doesArgumentTypehintMatchParam(ParamTag $param, ArgumentReflector $argument, $element)
{
if (!$argument->getType() || in_array($argument->getType(), $param->getTypes())) {
return null;
} elseif ($argument->getType() == 'array' && substr($param->getType(), -2) == '[]') {
return null;
}
return new Error(LogLevel::ERROR, 'PPC:ERR-50016', $argument->getLinenumber(), array($argument->getName(), $element->getName()));
}
