/**
* @param AbstractUnitObject $unit
*/
public function importExports(AbstractUnitObject $unit, $container = 'parent')
{
$parent = $this->rootNode->queryOne(sprintf('//phpdox:%s[@full="%s"]', $container, $unit->getName()));
if ($parent instanceof fDOMElement) {
$parent->parentNode->removeChild($parent);
}
$parent = $this->rootNode->appendElementNS(self::XMLNS, $container);
$parent->setAttribute('full', $unit->getName());
$parent->setAttribute('namepsace', $unit->getNamespace());
$parent->setAttribute('name', $unit->getLocalName());
if ($unit->hasExtends()) {
foreach ($unit->getExtends() as $name) {
$extends = $parent->appendElementNS(self::XMLNS, 'extends');
$this->setName($name, $extends);
}
}
foreach ($unit->getConstants() as $constant) {
$parent->appendChild($this->dom->importNode($constant->export(), TRUE));
}
foreach ($unit->getExportedMembers() as $member) {
$parent->appendChild($this->dom->importNode($member->export(), TRUE));
}
foreach ($unit->getExportedMethods() as $method) {
$parent->appendChild($this->dom->importNode($method->export(), TRUE));
}
}
protected function processFinding(fDOMDocument $dom, $ref, \DOMElement $finding)
{
$enrichment = $this->getEnrichtmentContainer($ref, 'checkstyle');
$enrichFinding = $dom->createElementNS(self::XMLNS, $finding->tagName);
$enrichment->appendChild($enrichFinding);
foreach ($finding->attributes as $attr) {
if ($attr->localName == 'severity') {
continue;
}
$enrichFinding->setAttributeNode($dom->importNode($attr, true));
}
$enrichFinding->setAttribute('message', $finding->nodeValue);
}
public function importTraitExports(AbstractUnitObject $trait, TraitUseObject $use)
{
$container = $this->rootNode->queryOne(sprintf('phpdox:trait[@full="%s"]', $trait->getName()));
if ($container instanceof fDOMElement) {
$container->parentNode->removeChild($container);
}
$container = $this->rootNode->appendElementNS(self::XMLNS, 'trait');
$this->setName($trait->getName(), $container);
if ($trait->hasExtends()) {
foreach ($trait->getExtends() as $name) {
$extends = $container->appendElementNS(self::XMLNS, 'extends');
$this->setName($name, $extends);
}
}
if ($trait->usesTraits()) {
foreach ($trait->getUsedTraits() as $name) {
$used = $container->appendElementNS(self::XMLNS, 'uses');
$this->setName($name, $used);
}
}
foreach ($trait->getConstants() as $constant) {
$container->appendChild($this->dom->importNode($constant->export(), TRUE));
}
foreach ($trait->getExportedMembers() as $member) {
$memberNode = $this->dom->importNode($member->export(), TRUE);
$this->adjustStaticResolution($memberNode);
$container->appendChild($memberNode);
}
foreach ($trait->getExportedMethods() as $method) {
$methodName = $method->getName();
$methodNode = $this->dom->importNode($method->export(), TRUE);
if (!$use->isExcluded($methodName)) {
$container->appendChild($methodNode);
}
$this->adjustStaticResolution($methodNode);
$aliasNode = NULL;
if ($use->isAliased($methodName)) {
$aliasNode = $methodNode->cloneNode(true);
$aliasNode->setAttribute('original', $aliasNode->getAttribute('name'));
$aliasNode->setAttribute('name', $use->getAliasedName($methodName));
if ($use->hasAliasedModifier($methodName)) {
$aliasNode->setAttribute('visibility', $use->getAliasedModifier($methodName));
}
$container->appendChild($aliasNode);
}
}
}
private function processViolations(fDOMDocument $dom, \DOMNodeList $violations)
{
foreach ($violations as $violation) {
/** @var fDOMElement $violation */
$line = $violation->getAttribute('beginline');
$ref = $dom->queryOne(sprintf('//phpdox:*/*[@line = %d or (@start <= %d and @end >= %d)]', $line, $line, $line));
if (!$ref) {
// One src file may contain multiple classes/traits/interfaces, so the
// finding might not apply to the current object since violations are based on filenames
// but we have individual objects - so we just ignore the finding for this context
continue;
}
$enrichment = $this->getEnrichtmentContainer($ref, 'pmd');
$enrichViolation = $dom->createElementNS(self::XMLNS, 'violation');
$enrichment->appendChild($enrichViolation);
$enrichViolation->setAttribute('message', trim($violation->nodeValue));
foreach ($violation->attributes as $attr) {
$enrichViolation->setAttributeNode($dom->importNode($attr, true));
}
}
}
private function processFindings(fDOMDocument $dom, \DOMNodeList $findings)
{
foreach ($findings as $finding) {
/** @var fDOMElement $finding */
$line = $finding->getAttribute('line');
$ref = $dom->queryOne(sprintf('//phpdox:*/*[@line = %d or (@start <= %d and @end >= %d)]', $line, $line, $line));
if (!$ref) {
// One src file may contain multiple classes/traits/interfaces, so the
// finding might not apply to the current object since findings are based on filenames
// but we have individual objects - so we just ignore the finding for this context
continue;
}
$enrichment = $this->getEnrichtmentContainer($ref, 'checkstyle');
$enrichFinding = $dom->createElementNS(self::XMLNS, $finding->getAttribute('severity', 'error'));
$enrichment->appendChild($enrichFinding);
foreach ($finding->attributes as $attr) {
if ($attr->localName == 'severity') {
continue;
}
$enrichFinding->setAttributeNode($dom->importNode($attr, true));
}
}
}
private function genericProcess(fDOMDocument $dom)
{
$enrichment = $this->getEnrichtmentContainer($dom->documentElement, 'build');
$enrichment->appendChild($dom->importNode($this->getGeneralBuildInfo(), true));
}
public function asDom(fDOMDocument $dom)
{
return $dom->importNode($this->fragment, true);
}
private function processUnit(fDOMDocument $unit, fDOMDocument $coverage)
{
$enrichment = $this->getEnrichtmentContainer($unit->documentElement, 'phpunit');
$className = $unit->documentElement->getAttribute('name');
$classNamespace = $unit->documentElement->getAttribute('namespace');
$classNode = $coverage->queryOne(sprintf('//pu:class[@name = "%s" and pu:namespace[@name = "%s"]]', $className, $classNamespace));
if (!$classNode) {
// This class seems to be newer than the last phpunit run
return;
}
$coverageTarget = $enrichment->appendElementNS(self::XMLNS, 'coverage');
foreach (array('executable', 'executed', 'crap') as $attr) {
$coverageTarget->appendChild($coverageTarget->ownerDocument->importNode($classNode->getAttributeNode($attr)));
}
$result = array('PASSED' => 0, 'SKIPPED' => 0, 'INCOMPLETE' => 0, 'FAILURE' => 0, 'ERROR' => 0, 'RISKY' => 0);
$methods = $unit->query('/phpdox:*/phpdox:constructor|/phpdox:*/phpdox:destructor|/phpdox:*/phpdox:method');
$xp = $this->index->getDOMXPath();
foreach ($methods as $method) {
$start = $method->getAttribute('start');
$end = $method->getAttribute('end');
$enrichment = $this->getEnrichtmentContainer($method, 'phpunit');
$coverageTarget = $enrichment->appendElementNS(self::XMLNS, 'coverage');
/** @var fDOMElement $coverageMethod */
$coverageMethod = $coverage->queryOne(sprintf('//pu:method[@start = "%d" and @end = "%d"]', $start, $end));
if ($coverageMethod != NULL) {
foreach (array('executable', 'executed', 'coverage', 'crap') as $attr) {
$coverageTarget->appendChild($coverageTarget->ownerDocument->importNode($coverageMethod->getAttributeNode($attr)));
}
}
$coveredNodes = $coverage->query(sprintf('//pu:coverage/pu:line[@nr >= "%d" and @nr <= "%d"]/pu:covered', $start, $end));
$seen = array();
foreach ($coveredNodes as $coveredNode) {
$by = $coveredNode->getAttribute('by');
if (isset($seen[$by])) {
continue;
}
$seen[$by] = true;
$name = $xp->prepare(':name', array('name' => $by));
$test = $coverageTarget->appendChild($unit->importNode($this->index->queryOne(sprintf('//pu:tests/pu:test[@name = %s]', $name))));
$result[$test->getAttribute('status')]++;
}
}
if (!isset($this->results[$classNamespace])) {
$this->results[$classNamespace] = array();
$this->coverage[$classNamespace] = array();
}
$this->results[$classNamespace][$className] = $result;
$this->coverage[$classNamespace][$className] = $coverageTarget->cloneNode(false);
}
/**
* Merge all files.
*
* @param string $directory
* @param Finder $finder
*
* @return fDOMDocument
*/
private function mergeFiles($directory, Finder $finder)
{
$outXml = new fDOMDocument();
$outXml->formatOutput = true;
$outTestSuites = $outXml->createElement('testsuites');
$outXml->appendChild($outTestSuites);
$outTestSuite = $outXml->createElement('testsuite');
$outTestSuites->appendChild($outTestSuite);
$tests = 0;
$assertions = 0;
$failures = 0;
$errors = 0;
$time = 0;
/** @var SplFileInfo $file */
foreach ($finder as $file) {
if ($this->isFileEmpty($file)) {
continue;
}
$inXml = $this->loadFile($file->getRealpath());
foreach ($inXml->query('//testsuites/testsuite') as $inElement) {
$inName = $inElement->getAttribute('name');
$outName = $inName;
$suffix = 2;
while ($outTestSuite->query('//testsuite[@name="' . $outName . '"]')->length !== 0) {
$outName = $inName . '_' . $suffix;
$suffix++;
}
$outElement = $outXml->importNode($inElement, true);
$outElement->setAttribute('name', $outName);
$outTestSuite->appendChild($outElement);
$tests += $inElement->getAttribute('tests');
$assertions += $inElement->getAttribute('assertions');
$failures += $inElement->getAttribute('failures');
$errors += $inElement->getAttribute('errors');
$time += $inElement->getAttribute('time');
}
}
$outTestSuite->setAttribute('name', $directory);
$outTestSuite->setAttribute('tests', $tests);
$outTestSuite->setAttribute('assertions', $assertions);
$outTestSuite->setAttribute('failures', $failures);
$outTestSuite->setAttribute('errors', $errors);
$outTestSuite->setAttribute('time', $time);
return $outXml;
}
