BaseScanner::getValidatorCollection() - Code Metrics - dunkelfrosch/phpcoverfish - Measure and Improve Code Quality continuously with Scrutinizer

BaseScanner::getValidatorCollection() A
last analyzed 2018-05-15 15:08 UTC

↳ Parent: BaseScanner

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	4
rs	10
c	0
b	0
f	0
cc	1
eloc	2
nc	1
nop	0

<?php

namespace DF\PHPCoverFish\Base;

use DF\PHPCoverFish\Common\ArrayCollection;
use DF\PHPCoverFish\Common\CoverFishOutput;
use DF\PHPCoverFish\Common\CoverFishPHPUnitFile;
use DF\PHPCoverFish\Common\CoverFishPHPUnitTest;
use DF\PHPCoverFish\Common\CoverFishResult;
use DF\PHPCoverFish\Common\CoverFishHelper;
use DF\PHPCoverFish\Validator\Base\BaseCoverFishValidatorInterface as CoverFishValidatorInterface;
use SebastianBergmann\FinderFacade\FinderFacade;

/**
 * Class BaseScanner
 *
 * @package   DF\PHPCoverFish
 * @author    Patrick Paechnatz <[email protected]>
 * @copyright 2015 Patrick Paechnatz <[email protected]>
 * @license   http://www.opensource.org/licenses/MIT
 * @link      http://github.com/dunkelfrosch/phpcoverfish/tree
 * @since     class available since Release 0.9.9
 * @version   1.0.0
 */
class BaseScanner
{
    /**
     * @var string
     */
    protected $phpUnitXMLPath;

    /**
     * @var string
     */
    protected $phpUnitXMLFile;

    /**
     * @var string
     */
    protected $phpUnitTestSuite;

    /**
     * @var string
     */
    protected $testSourcePath;

    /**
     * @var String
     */
    protected $testExcludePath;

    /**
     * @var String
     */
    protected $testAutoloadPath;

    /**
     * @var bool
     */
    protected $passes;

    /**
     * @var array
     */
    protected $usedClasses;

    /**
     * @var CoverFishPHPUnitFile
     */
    protected $phpUnitFile;

    /**
     * @var CoverFishPHPUnitTest
     */
    protected $phpUnitTest;

    /**
     * @var CoverFishHelper
     */
    protected $coverFishHelper;

    /**
     * @var CoverFishResult
     */
    protected $coverFishResult;

    /**
     * @var CoverFishOutput
     */
    protected $coverFishOutput;

    /**
     * @var ArrayCollection
     */
    protected $validatorCollection;

    /**
     * @var bool
     */
    protected $stopOnError = false;

    /**
     * @var bool
     */
    protected $stopOnFailure = false;

    /**
     * @var string
     */
    protected $filePattern = '*.*';

    /**
     * @var array
     */
    protected $filePatternExclude = array(
        '*.log',
        '*.txt',
        '*.md'
    );

    /**
     * @return boolean
     */
    public function isStopOnError()
    {
        return $this->stopOnError;
    }

    /**
     * @return boolean
     */
    public function isStopOnFailure()
    {
        return $this->stopOnFailure;
    }

    /**
     * @return string
     */
    public function getPhpUnitXMLPath()
    {
        return $this->phpUnitXMLPath;
    }

    /**
     * @return string
     */
    public function getPhpUnitXMLFile()
    {
        return $this->phpUnitXMLFile;
    }

    /**
     * @return string
     */
    public function getPhpUnitTestSuite()
    {
        return $this->phpUnitTestSuite;
    }

    /**
     * @return ArrayCollection
     */
    public function getValidatorCollection()
    {
        return $this->validatorCollection;
    }

    /**
     * @todo rename this variable to (get)TestSourcePathOrFile
     *
     * @codeCoverageIgnore
     *
     * @return string
     */
    public function getTestSourcePath()
    {
        return $this->testSourcePath;
    }

    /**
     * return the excluded path, remove the last backslash before return
     *
     * @codeCoverageIgnore
     *
     * @return String
     */
    public function getTestExcludePath()
    {
        return rtrim($this->testExcludePath, '/');
    }

    /**
     * @codeCoverageIgnore
     *
     * @return String
     */
    public function getTestAutoloadPath()
    {
        return $this->testAutoloadPath;
    }

    /**
     * @codeCoverageIgnore
     *
     * @return CoverFishPHPUnitFile
     */
    public function getPhpUnitFile()
    {
        return $this->phpUnitFile;
    }

    /**
     * @codeCoverageIgnore
     *
     * @return CoverFishPHPUnitTest
     */
    public function getPhpUnitTest()
    {
        return $this->phpUnitTest;
    }

    /**
     * @codeCoverageIgnore
     *
     * @return CoverFishHelper
     */
    public function getCoverFishHelper()
    {
        return $this->coverFishHelper;
    }

    /**
     * @param CoverFishPHPUnitTest $phpUnitTest
     *
     * @codeCoverageIgnore
     */
    public function setPhpUnitTest($phpUnitTest)
    {
        $this->phpUnitTest = $phpUnitTest;
    }

    /**
     * @codeCoverageIgnore
     */
    public function __construct()
    {
        $this->validatorCollection = new ArrayCollection();
        $this->coverFishHelper = new CoverFishHelper();
        $this->coverFishResult = new CoverFishResult();
    }

    /**
     * check existence of given autoload file (raw/psr-0/psr-4)
     *
     * @param string $autoloadFile
     *
     * @return bool
     *
     * @throws \Exception
     */
    public function checkSourceAutoload($autoloadFile)
    {
        if (false === $this->coverFishHelper->checkFileExist($autoloadFile)) {
            throw new \Exception(sprintf('autoload file "%s" not found! please define your autoload.php file to use (e.g. ../app/autoload.php in symfony)', $autoloadFile));
        }

        return true;
    }

    /**
     * get a testSuite main attribute of given phpunit xml file (like name, bootstrap ...)
     *
     * @param string            $attribute
     * @param \SimpleXMLElement $xmlDocument
     *
     * @return bool|string
     */
    public function getAttributeFromXML($attribute, \SimpleXMLElement $xmlDocument)
    {
        /** @var \SimpleXMLElement $value */
        foreach ($xmlDocument->attributes() as $key => $value) {
            /** @var \SimpleXMLElement $attribute */
            if ($attribute === $key) {
                return (string) ($this->xmlToArray($value)[0]);
            }
        }

        return false;
    }

    /**
     * function will return the first testSuite directory found in testSuites node-block.
     * if no "$this->phpUnitTestSuite" provided, first testSuite will be returned!
     *
     * @param \SimpleXMLElement $xmlDocumentNodes
     *
     * @return bool|\SimpleXMLElement
     */
    public function getTestSuiteNodeFromXML(\SimpleXMLElement $xmlDocumentNodes) {

        /** @var \SimpleXMLElement $suite */
        foreach ($xmlDocumentNodes->testsuites->testsuite as $suite) {

            if (false === $suiteName = $this->getAttributeFromXML('name', $suite)) {
                continue;
            }

            if ((true === empty($this->phpUnitTestSuite)) || ($suiteName === $this->phpUnitTestSuite)) {
                return $suite;
            }
        }

        return false;
    }

    /**
     * get a specific property from named testSuite node (like "exclude" or "directory")
     *
     * @param string            $property
     * @param \SimpleXMLElement $xmlDocumentNodes
     *
     * @return bool|string
     */
    public function getTestSuitePropertyFromXML($property, \SimpleXMLElement $xmlDocumentNodes)
    {
        /** @var \SimpleXMLElement $suite */
        $suite = $this->getTestSuiteNodeFromXML($xmlDocumentNodes);
        if (false === empty($suite) && property_exists($suite, $property)) {
            return (string) ($this->xmlToArray($suite->$property)[0]);
        }

        return false;
    }

    /**
     * @param \SimpleXMLElement|array $xmlObject
     * @param array                   $output
     *
     * @return array
     */
    public function xmlToArray($xmlObject, $output = array())
    {
        foreach ((array) $xmlObject as $index => $node) {
            $output[$index] = ($node instanceof \SimpleXMLElement || is_array($node))
                ? $this->xmlToArray($node)
                : $node;
        }

        return $output;
    }

    /**
     * @param CoverFishValidatorInterface $validator
     *
     * @return ArrayCollection
     */
    public function addValidator(CoverFishValidatorInterface $validator)
    {
        $this->validatorCollection->add($validator);
    }

    /**
     * workaround for missing/buggy path exclude in symfony finder class
     *
     * @param array  $files
     * @param string $excludePath
     *
     * @return array
     */
    public function removeExcludedPath(array $files, $excludePath)
    {
        $result = $includedFiles = array();

        if (true === empty($excludePath)) {
            return $files;
        }

        foreach ($files as $filePath) {
            preg_match_all($this->coverFishHelper->getRegexPath($excludePath), $filePath, $result, PREG_SET_ORDER);
            if (true === empty($result)) {
                $includedFiles[] = $filePath;
            }
        }

        return $includedFiles;
    }

    /**
     * scan all files by given path recursively, if one php file will be provided within given path,
     * this file will be returned in finder format
     *
     * @param string $sourcePath
     *
     * @return array
     */
    public function scanFilesInPath($sourcePath)
    {
        $filePattern = $this->filePattern;
        if (strpos($sourcePath, str_replace('*', null, $filePattern))) {
            $filePattern = $this->coverFishHelper->getFileNameFromPath($sourcePath);
        }

        $facade = new FinderFacade(
            array($sourcePath),
            $this->filePatternExclude,
            array($filePattern)
        );

        return $this->removeExcludedPath($facade->findFiles(), $this->testExcludePath);
    }
}

1			<?php
2
3			namespace DF\PHPCoverFish\Base;
4
5			use DF\PHPCoverFish\Common\ArrayCollection;
6			use DF\PHPCoverFish\Common\CoverFishOutput;
7			use DF\PHPCoverFish\Common\CoverFishPHPUnitFile;
8			use DF\PHPCoverFish\Common\CoverFishPHPUnitTest;
9			use DF\PHPCoverFish\Common\CoverFishResult;
10			use DF\PHPCoverFish\Common\CoverFishHelper;
11			use DF\PHPCoverFish\Validator\Base\BaseCoverFishValidatorInterface as CoverFishValidatorInterface;
12			use SebastianBergmann\FinderFacade\FinderFacade;
13
14			/**
15			* Class BaseScanner
16			*
17			* @package DF\PHPCoverFish
18			* @author Patrick Paechnatz <[email protected]>
19			* @copyright 2015 Patrick Paechnatz <[email protected]>
20			* @license http://www.opensource.org/licenses/MIT
21			* @link http://github.com/dunkelfrosch/phpcoverfish/tree
22			* @since class available since Release 0.9.9
23			* @version 1.0.0
24			*/
25			class BaseScanner
26			{
27			/**
28			* @var string
29			*/
30			protected $phpUnitXMLPath;
31
32			/**
33			* @var string
34			*/
35			protected $phpUnitXMLFile;
36
37			/**
38			* @var string
39			*/
40			protected $phpUnitTestSuite;
41
42			/**
43			* @var string
44			*/
45			protected $testSourcePath;
46
47			/**
48			* @var String
49			*/
50			protected $testExcludePath;
51
52			/**
53			* @var String
54			*/
55			protected $testAutoloadPath;
56
57			/**
58			* @var bool
59			*/
60			protected $passes;
61
62			/**
63			* @var array
64			*/
65			protected $usedClasses;
66
67			/**
68			* @var CoverFishPHPUnitFile
69			*/
70			protected $phpUnitFile;
71
72			/**
73			* @var CoverFishPHPUnitTest
74			*/
75			protected $phpUnitTest;
76
77			/**
78			* @var CoverFishHelper
79			*/
80			protected $coverFishHelper;
81
82			/**
83			* @var CoverFishResult
84			*/
85			protected $coverFishResult;
86
87			/**
88			* @var CoverFishOutput
89			*/
90			protected $coverFishOutput;
91
92			/**
93			* @var ArrayCollection
94			*/
95			protected $validatorCollection;
96
97			/**
98			* @var bool
99			*/
100			protected $stopOnError = false;
101
102			/**
103			* @var bool
104			*/
105			protected $stopOnFailure = false;
106
107			/**
108			* @var string
109			*/
110			protected $filePattern = '.';
111
112			/**
113			* @var array
114			*/
115			protected $filePatternExclude = array(
116			'*.log',
117			'*.txt',
118			'*.md'
119			);
120
121			/**
122			* @return boolean
123			*/
124			public function isStopOnError()
125			{
126			return $this->stopOnError;
127			}
128
129			/**
130			* @return boolean
131			*/
132			public function isStopOnFailure()
133			{
134			return $this->stopOnFailure;
135			}
136
137			/**
138			* @return string
139			*/
140			public function getPhpUnitXMLPath()
141			{
142			return $this->phpUnitXMLPath;
143			}
144
145			/**
146			* @return string
147			*/
148			public function getPhpUnitXMLFile()
149			{
150			return $this->phpUnitXMLFile;
151			}
152
153			/**
154			* @return string
155			*/
156			public function getPhpUnitTestSuite()
157			{
158			return $this->phpUnitTestSuite;
159			}
160
161			/**
162			* @return ArrayCollection
163			*/
164			public function getValidatorCollection()
165			{
166			return $this->validatorCollection;
167			}
168
169			/**
170			* @todo rename this variable to (get)TestSourcePathOrFile
171			*
172			* @codeCoverageIgnore
173			*
174			* @return string
175			*/
176			public function getTestSourcePath()
177			{
178			return $this->testSourcePath;
179			}
180
181			/**
182			* return the excluded path, remove the last backslash before return
183			*
184			* @codeCoverageIgnore
185			*
186			* @return String
187			*/
188			public function getTestExcludePath()
189			{
190			return rtrim($this->testExcludePath, '/');
191			}
192
193			/**
194			* @codeCoverageIgnore
195			*
196			* @return String
197			*/
198			public function getTestAutoloadPath()
199			{
200			return $this->testAutoloadPath;
201			}
202
203			/**
204			* @codeCoverageIgnore
205			*
206			* @return CoverFishPHPUnitFile
207			*/
208			public function getPhpUnitFile()
209			{
210			return $this->phpUnitFile;
211			}
212
213			/**
214			* @codeCoverageIgnore
215			*
216			* @return CoverFishPHPUnitTest
217			*/
218			public function getPhpUnitTest()
219			{
220			return $this->phpUnitTest;
221			}
222
223			/**
224			* @codeCoverageIgnore
225			*
226			* @return CoverFishHelper
227			*/
228			public function getCoverFishHelper()
229			{
230			return $this->coverFishHelper;
231			}
232
233			/**
234			* @param CoverFishPHPUnitTest $phpUnitTest
235			*
236			* @codeCoverageIgnore
237			*/
238			public function setPhpUnitTest($phpUnitTest)
239			{
240			$this->phpUnitTest = $phpUnitTest;
241			}
242
243			/**
244			* @codeCoverageIgnore
245			*/
246			public function __construct()
247			{
248			$this->validatorCollection = new ArrayCollection();
249			$this->coverFishHelper = new CoverFishHelper();
250			$this->coverFishResult = new CoverFishResult();
251			}
252
253			/**
254			* check existence of given autoload file (raw/psr-0/psr-4)
255			*
256			* @param string $autoloadFile
257			*
258			* @return bool
259			*
260			* @throws \Exception
261			*/
262			public function checkSourceAutoload($autoloadFile)
263			{
264			if (false === $this->coverFishHelper->checkFileExist($autoloadFile)) {
265			throw new \Exception(sprintf('autoload file "%s" not found! please define your autoload.php file to use (e.g. ../app/autoload.php in symfony)', $autoloadFile));
266			}
267
268			return true;
269			}
270
271			/**
272			* get a testSuite main attribute of given phpunit xml file (like name, bootstrap ...)
273			*
274			* @param string $attribute
275			* @param \SimpleXMLElement $xmlDocument
276			*
277			* @return bool\|string
278			*/
279			public function getAttributeFromXML($attribute, \SimpleXMLElement $xmlDocument)
280			{
281			/** @var \SimpleXMLElement $value */
282			foreach ($xmlDocument->attributes() as $key => $value) {
283			/** @var \SimpleXMLElement $attribute */
284			if ($attribute === $key) {
285			return (string) ($this->xmlToArray($value)[0]);
286			}
287			}
288
289			return false;
290			}
291
292			/**
293			* function will return the first testSuite directory found in testSuites node-block.
294			* if no "$this->phpUnitTestSuite" provided, first testSuite will be returned!
295			*
296			* @param \SimpleXMLElement $xmlDocumentNodes
297			*
298			* @return bool\|\SimpleXMLElement
299			*/
300			public function getTestSuiteNodeFromXML(\SimpleXMLElement $xmlDocumentNodes) {
301
302			/** @var \SimpleXMLElement $suite */
303			foreach ($xmlDocumentNodes->testsuites->testsuite as $suite) {
304
305			if (false === $suiteName = $this->getAttributeFromXML('name', $suite)) {
306			continue;
307			}
308
309			if ((true === empty($this->phpUnitTestSuite)) \|\| ($suiteName === $this->phpUnitTestSuite)) {
310			return $suite;
311			}
312			}
313
314			return false;
315			}
316
317			/**
318			* get a specific property from named testSuite node (like "exclude" or "directory")
319			*
320			* @param string $property
321			* @param \SimpleXMLElement $xmlDocumentNodes
322			*
323			* @return bool\|string
324			*/
325			public function getTestSuitePropertyFromXML($property, \SimpleXMLElement $xmlDocumentNodes)
326			{
327			/** @var \SimpleXMLElement $suite */
328			$suite = $this->getTestSuiteNodeFromXML($xmlDocumentNodes);
329			if (false === empty($suite) && property_exists($suite, $property)) {
330			return (string) ($this->xmlToArray($suite->$property)[0]);
331			}
332
333			return false;
334			}
335
336			/**
337			* @param \SimpleXMLElement\|array $xmlObject
338			* @param array $output
339			*
340			* @return array
341			*/
342			public function xmlToArray($xmlObject, $output = array())
343			{
344			foreach ((array) $xmlObject as $index => $node) {
345			$output[$index] = ($node instanceof \SimpleXMLElement \|\| is_array($node))
346			? $this->xmlToArray($node)
347			: $node;
348			}
349
350			return $output;
351			}
352
353			/**
354			* @param CoverFishValidatorInterface $validator
355			*
356			* @return ArrayCollection
357			*/
358			public function addValidator(CoverFishValidatorInterface $validator)
359			{
360			$this->validatorCollection->add($validator);
361			}
362
363			/**
364			* workaround for missing/buggy path exclude in symfony finder class
365			*
366			* @param array $files
367			* @param string $excludePath
368			*
369			* @return array
370			*/
371			public function removeExcludedPath(array $files, $excludePath)
372			{
373			$result = $includedFiles = array();
374
375			if (true === empty($excludePath)) {
376			return $files;
377			}
378
379			foreach ($files as $filePath) {
380			preg_match_all($this->coverFishHelper->getRegexPath($excludePath), $filePath, $result, PREG_SET_ORDER);
381			if (true === empty($result)) {
382			$includedFiles[] = $filePath;
383			}
384			}
385
386			return $includedFiles;
387			}
388
389			/**
390			* scan all files by given path recursively, if one php file will be provided within given path,
391			* this file will be returned in finder format
392			*
393			* @param string $sourcePath
394			*
395			* @return array
396			*/
397			public function scanFilesInPath($sourcePath)
398			{
399			$filePattern = $this->filePattern;
400			if (strpos($sourcePath, str_replace('*', null, $filePattern))) {
401			$filePattern = $this->coverFishHelper->getFileNameFromPath($sourcePath);
402			}
403
404			$facade = new FinderFacade(
405			array($sourcePath),
406			$this->filePatternExclude,
407			array($filePattern)
408			);
409
410			return $this->removeExcludedPath($facade->findFiles(), $this->testExcludePath);
411			}
412			}

dunkelfrosch / phpcoverfish

GitHub Access Token became invalid

BaseScanner::getValidatorCollection() A last analyzed 2018-05-15 15:08 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

BaseScanner::getValidatorCollection() A
last analyzed 2018-05-15 15:08 UTC