TestFileLoader::loadFile() - Code Metrics - brianium/paratest - Measure and Improve Code Quality continuously with Scrutinizer

TestFileLoader::loadFile() A
last analyzed 2018-01-27 11:59 UTC

↳ Parent: TestFileLoader

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	3
CRAP Score	1

Importance

Changes

Metric	Value
dl	0
loc	4
ccs	3
cts	3
cp	1
rs	10
c	0
b	0
f	0
cc	1
eloc	2
nc	1
nop	1
crap	1

<?php

declare(strict_types=1);

namespace ParaTest\Runners\PHPUnit;

class TestFileLoader
{
    /**
     * The pattern used for grabbing test files. Uses the *Test.php convention
     * that PHPUnit defaults to.
     */
    const TEST_PATTERN = '/.+Test\.php$/';

    /**
     * Matches php files.
     */
    const FILE_PATTERN = '/.+\.php$/';

    /**
     * Used to ignore directory paths '.' and '..'.
     *
     * @var string
     */
    private static $dotPattern = '/([.]+)$/';

    /**
     * The collection of loaded files for this test suite.
     *
     * @var array
     */
    protected $files = [];

    /**
     * The collection of excluded files.
     *
     * @var array
     */
    protected $excludedFiles = [];

    /**
     * When true, the SuiteLoader add the files to excluded files.
     *
     * @var bool
     */
    protected $excludingFiles = false;

    public function __construct(Options $options = null)
    {
        $this->options = $options;
class MyClass { }

$x = new MyClass();
$x->foo = true;
    }

    /**
     * Loads a SuitePath and makes sure to
     * take into account the excluded directory / files.
     *
     * @param SuitePath $path
     *
     * @return string[]
     */
    public function loadSuitePath(SuitePath $path): array
    {
        // First initialize the list of files and excluded files
        $this->files = [];
        $this->excludedFiles = [];
        $this->excludingFiles = true;
        foreach ($path->getExcludedPaths() as $excludedPath) {
            $this->loadPath($excludedPath, $path->getPattern());
        }

        // Load the SuitePath
        $this->excludingFiles = false;
        $this->loadPath($path->getPath(), $path->getPattern());

        // Reinitialise the excluded files
        $this->excludedFiles = [];

        return $this->files;
    }

    /**
     * Loads suites based on a specific path.
     * A valid path can be a directory or file.
     *
     * @param $path
     * @param $pattern
     *
     * @throws \InvalidArgumentException
     *
     * @return string[]
     */
    public function loadPath(string $path, string $pattern = null): array
    {
        $this->files = [];
        $path = $path ?: $this->options->path;
        $pattern = null === $pattern ? self::TEST_PATTERN : $pattern;

        if (!file_exists($path)) {
            throw new \InvalidArgumentException("$path is not a valid directory or file");
        }
        if (is_dir($path)) {
            $this->loadDir($path, $pattern);
        } elseif (file_exists($path)) {
            $this->loadFile($path);
        }

        return $this->files;
    }

    /**
     * Loads suites from a directory.
     *
     * @param string $path
     * @param string $pattern
     */
    private function loadDir(string $path, string $pattern = self::TEST_PATTERN)
    {
        $files = scandir($path);
        foreach ($files as $file) {
            $this->tryLoadTests($path . DIRECTORY_SEPARATOR . $file, $pattern);
        }
    }

    /**
     * Load a single suite file.
     *
     * @param $path
     */
    private function loadFile(string $path)
    {
        $this->tryLoadTests($path, self::FILE_PATTERN);
    }

    /**
     * Attempts to load suites from a path.
     *
     * @param string $path
     * @param string $pattern regular expression for matching file names
     */
    private function tryLoadTests(string $path, string $pattern = self::TEST_PATTERN)
    {
        if (preg_match($pattern, $path)) {
            if ($this->excludingFiles) {
                $this->excludedFiles[$path] = $path;
            } elseif (!array_key_exists($path, $this->excludedFiles)) {
                $this->files[] = $path;
            }
        }

        if (!preg_match(self::$dotPattern, $path) && is_dir($path)) {
            $this->loadDir($path, $pattern);
        }
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace ParaTest\Runners\PHPUnit;
6
7		class TestFileLoader
8		{
9		/**
10		* The pattern used for grabbing test files. Uses the *Test.php convention
11		* that PHPUnit defaults to.
12		*/
13		const TEST_PATTERN = '/.+Test\.php$/';
14
15		/**
16		* Matches php files.
17		*/
18		const FILE_PATTERN = '/.+\.php$/';
19
20		/**
21		* Used to ignore directory paths '.' and '..'.
22		*
23		* @var string
24		*/
25		private static $dotPattern = '/([.]+)$/';
26
27		/**
28		* The collection of loaded files for this test suite.
29		*
30		* @var array
31		*/
32		protected $files = [];
33
34		/**
35		* The collection of excluded files.
36		*
37		* @var array
38		*/
39		protected $excludedFiles = [];
40
41		/**
42		* When true, the SuiteLoader add the files to excluded files.
43		*
44		* @var bool
45		*/
46		protected $excludingFiles = false;
47
48	24	public function __construct(Options $options = null)
49		{
50	24	$this->options = $options;
		0 ignored issues – show Bug introduced 2017-07-06 08:05 UTC by Report Bug Copy Issue Report The property `options` does not exist. Did you maybe forget to declare it? In PHP it is possible to write to properties without declaring them. For example, the following is perfectly valid PHP code: class MyClass { } $x = new MyClass(); $x->foo = true; Generally, it is a good practice to explictly declare properties to avoid accidental typos and provide IDE auto-completion: class MyClass { public $foo; } $x = new MyClass(); $x->foo = true; Loading history...
51	24	}
52
53		/**
54		* Loads a SuitePath and makes sure to
55		* take into account the excluded directory / files.
56		*
57		* @param SuitePath $path
58		*
59		* @return string[]
60		*/
61	12	public function loadSuitePath(SuitePath $path): array
62		{
63		// First initialize the list of files and excluded files
64	12	$this->files = [];
65	12	$this->excludedFiles = [];
66	12	$this->excludingFiles = true;
67	12	foreach ($path->getExcludedPaths() as $excludedPath) {
68	2	$this->loadPath($excludedPath, $path->getPattern());
69		}
70
71		// Load the SuitePath
72	12	$this->excludingFiles = false;
73	12	$this->loadPath($path->getPath(), $path->getPattern());
74
75		// Reinitialise the excluded files
76	12	$this->excludedFiles = [];
77
78	12	return $this->files;
79		}
80
81		/**
82		* Loads suites based on a specific path.
83		* A valid path can be a directory or file.
84		*
85		* @param $path
86		* @param $pattern
87		*
88		* @throws \InvalidArgumentException
89		*
90		* @return string[]
91		*/
92	22	public function loadPath(string $path, string $pattern = null): array
93		{
94	22	$this->files = [];
95	22	$path = $path ?: $this->options->path;
96	22	$pattern = null === $pattern ? self::TEST_PATTERN : $pattern;
97
98	22	if (!file_exists($path)) {
99	2	throw new \InvalidArgumentException("$path is not a valid directory or file");
100		}
101	20	if (is_dir($path)) {
102	13	$this->loadDir($path, $pattern);
103	11	} elseif (file_exists($path)) {
104	11	$this->loadFile($path);
105		}
106
107	20	return $this->files;
108		}
109
110		/**
111		* Loads suites from a directory.
112		*
113		* @param string $path
114		* @param string $pattern
115		*/
116	13	private function loadDir(string $path, string $pattern = self::TEST_PATTERN)
117		{
118	13	$files = scandir($path);
119	13	foreach ($files as $file) {
120	13	$this->tryLoadTests($path . DIRECTORY_SEPARATOR . $file, $pattern);
121		}
122	13	}
123
124		/**
125		* Load a single suite file.
126		*
127		* @param $path
128		*/
129	11	private function loadFile(string $path)
130		{
131	11	$this->tryLoadTests($path, self::FILE_PATTERN);
132	11	}
133
134		/**
135		* Attempts to load suites from a path.
136		*
137		* @param string $path
138		* @param string $pattern regular expression for matching file names
139		*/
140	20	private function tryLoadTests(string $path, string $pattern = self::TEST_PATTERN)
141		{
142	20	if (preg_match($pattern, $path)) {
143	20	if ($this->excludingFiles) {
144	2	$this->excludedFiles[$path] = $path;
145	20	} elseif (!array_key_exists($path, $this->excludedFiles)) {
146	20	$this->files[] = $path;
147		}
148		}
149
150	20	if (!preg_match(self::$dotPattern, $path) && is_dir($path)) {
151	8	$this->loadDir($path, $pattern);
152		}
153	20	}
154		}
155

brianium / paratest

TestFileLoader::loadFile() A last analyzed 2018-01-27 11:59 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

TestFileLoader::loadFile() A
last analyzed 2018-01-27 11:59 UTC