PHP fDOMDocument::queryOne方法代码示例

 /**
  * @return bool
  */
 public function isSilentMode()
 {
     $root = $this->cfg->queryOne('/cfg:phpdox');
     if (!$root instanceof \DomNode) {
         return false;
     }
     return $root->getAttribute('silent', 'false') === 'true';
 }

 private function getCacheDom()
 {
     if ($this->cacheDom === NULL) {
         $this->cacheDom = new fDOMDocument();
         $cacheFile = $this->config->getLogfilePath();
         if (file_exists($cacheFile)) {
             $this->cacheDom->load($cacheFile);
             $sha1 = $this->cacheDom->documentElement->getAttribute('sha1');
             $cwd = getcwd();
             chdir($this->config->getSourceDirectory());
             exec($this->config->getGitBinary() . ' diff --name-only ' . $sha1, $files, $rc);
             foreach ($files as $file) {
                 $fields = array('path' => dirname($file), 'file' => basename($file));
                 $query = $this->cacheDom->prepareQuery('//*[@path = :path and @file = :file]', $fields);
                 $node = $this->cacheDom->queryOne($query);
                 if (!$node) {
                     continue;
                 }
                 $node->parentNode->removeChild($node);
             }
             chdir($cwd);
         } else {
             $this->cacheDom->loadXML('<?xml version="1.0" ?><gitlog xmlns="' . self::GITNS . '" />');
             $this->cacheDom->documentElement->setAttribute('sha1', $this->commitSha1);
         }
     }
     return $this->cacheDom;
 }

 public function import(fDOMDocument $dom) {
     $dom->registerNamespace('phpdox', 'http://xml.phpdox.net/src#');
     $dir = $dom->queryOne('/phpdox:source/phpdox:dir');
     if (!$dir)  {
         return;
     }
     $this->importDirNode($dir, '');
 }

 private function getMethod($name)
 {
     $ctx = $this->dom->queryOne(sprintf('phpdox:method[@name="%s"]', $name));
     if (!$ctx) {
         throw new UnitObjectException(sprintf('Method "%s" not found', $name), UnitObjectException::NoSuchMethod);
     }
     return new MethodObject($this, $ctx);
 }

 public function getProjectConfig($project)
 {
     $filter = is_int($project) ? $project : "@name = '{$project}'";
     $ctx = $this->cfg->queryOne("//cfg:project[{$filter}]");
     if (!$ctx) {
         throw new ConfigException("Project '{$project}' not found in configuration xml file", ConfigException::ProjectNotFound);
     }
     return new ProjectConfig($this->runResolver($ctx));
 }

 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;
         }
         $this->processFinding($dom, $ref, $finding);
     }
 }

 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));
         }
     }
 }

 /**
  * @return string
  */
 public function getInterfaceClassName()
 {
     return $this->dom->queryOne('configuration/interface')->getAttribute('name');
 }

 /**
  * @param fDOMDocument $dom
  *
  * @return fDOMDocument
  *
  * @throws EnricherException
  * @throws PHPUnitEnricherException
  */
 private function loadCoverageInformation(fDOMDocument $dom)
 {
     $fileNode = $dom->queryOne('//phpdox:file');
     if (!$fileNode) {
         throw new PHPUnitEnricherException('No file header in event dom');
     }
     $fileInfo = new FileInfo($fileNode->getAttribute('path'));
     $srcDir = $this->getSourceDirectory();
     $paths = explode('/', (string) $fileInfo->getRelative($srcDir));
     $file = $fileNode->getAttribute('file');
     $paths = array_slice($paths, 1);
     $query = sprintf('//pu:project/pu:directory[@name = "%s"]', $srcDir->getRealPath());
     foreach ($paths as $path) {
         $query .= sprintf('/pu:directory[@name = "%s"]', $path);
     }
     $query .= sprintf('/pu:file[@name = "%s"]', $file);
     $phpunitFileNode = $this->index->queryOne($query);
     if (!$phpunitFileNode) {
         throw new PHPUnitEnricherException('No coverage information for file');
     }
     $refDom = $this->loadXML($phpunitFileNode->getAttribute('href'));
     return $refDom;
 }

 /**
  * @return bool
  */
 public function isSilentMode()
 {
     $root = $this->cfg->queryOne('/cfg:phpdox');
     return $root->getAttribute('silent', 'false') === 'true';
 }

 /**
  * @param string[] $units
  * @param string[] $visibilities
  * @return fDOMDocument
  */
 private function createPhpDoxConfig(array $units, array $visibilities)
 {
     $dom = new fDOMDocument();
     $dom->loadXML($this->factory->getConfigSkeleton()->renderStripped());
     $dom->registerNamespace('config', ConfigLoader::XMLNS);
     // set up silent
     $silent = $this->output->getVerbosity() <= OutputInterface::VERBOSITY_NORMAL ? 'true' : 'false';
     $dom->queryOne('//config:phpdox')->setAttribute('silent', $silent);
     // set up directories
     $projectNode = $dom->queryOne('//config:project');
     $projectNode->setAttribute('source', $this->sourceDirectory);
     $projectNode->setAttribute('workdir', $this->buildDirectory);
     // inject flag to avoid unecessary processing according to the visibility filter
     if (1 === count($visibilities) && in_array('public', $visibilities)) {
         $collectorNode = $dom->queryOne('//config:collector');
         $projectNode->setAttribute('publiconly', 'true');
     }
     // remove current masks
     $query = "//config:collector/*[name()='include' or name()='exclude']";
     foreach ($dom->query($query) as $mask) {
         $mask->parentNode->removeChild($mask);
     }
     // append files to be parsed
     $collector = $dom->queryOne('//config:collector');
     foreach ($units as $unitFile) {
         $include = $dom->createElement('include');
         $include->setAttribute('mask', $unitFile);
         $collector->appendChild($include);
     }
     return $dom;
 }

 /**
  * @param $fname
  *
  * @return array
  */
 private function findAffectedUnits($fname)
 {
     $affected = array();
     $dom = new fDOMDocument();
     $dom->load($this->xmlDir . '/' . $fname);
     $dom->registerNamespace('phpdox', 'http://xml.phpdox.net/src#');
     $extends = $dom->queryOne('//phpdox:extends');
     if ($extends instanceof fDOMElement) {
         try {
             $affected[$extends->getAttribute('full')] = $this->getUnitByName($extends->getAttribute('full'));
         } catch (ProjectException $e) {
         }
     }
     $implements = $dom->query('//phpdox:implements');
     foreach ($implements as $implement) {
         try {
             $affected[$implement->getAttribute('full')] = $this->getUnitByName($implement->getAttribute('full'));
         } catch (ProjectException $e) {
         }
     }
     return $affected;
 }

        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);
        }

 /**
  * @covers \TheSeer\fDOM\fDOMDocument::queryOne
  */
 public function testThatTwoNodesAreIdentifiedAsBeingInTheSameDocument()
 {
     $this->dom->loadXML('<?xml version="1.0" ?><root><node /></root>');
     $node = $this->dom->queryOne('//node');
     $this->assertTrue($this->dom->inSameDocument($node));
 }