Parser::getClass() - Code Metrics - Inspection of "Merge pull request #249 from TysonAndre/stop-using..." - brianium/paratest - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( cd00cd...086849 )

by Julian

created 2017-06-23 10:27 UTC

Parser::getClass() A

↳ Parent: Parser

Complexity

Conditions	2
Paths	2

Size

Total Lines	11
Code Lines	8

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	7
CRAP Score	2.0078

Importance

Changes

Metric	Value
dl	0
loc	11
ccs	7
cts	8
cp	0.875
rs	9.4285
c	0
b	0
f	0
cc	2
eloc	8
nc	2
nop	0
crap	2.0078

<?php
namespace ParaTest\Parser;

class Parser
{
    /**
     * The path to the source file to parse
     *
     * @var string
     */
    private $path;

    /**
     * @var \ReflectionClass
     */
    private $refl;

    /**
     * Matches a test method beginning with the conventional "test"
     * word
     *
     * @var string
     */
    private static $testName = '/^test/';

    /**
     * A pattern for matching test methods that use the @test annotation
     *
     * @var string
     */
    private static $testAnnotation = '/@test\b/';

    public function __construct($srcPath)
    {
        if (!file_exists($srcPath)) {
            throw new \InvalidArgumentException("file not found: " . $srcPath);
        }

        $this->path = $srcPath;
        $declaredClasses = get_declared_classes();
        require_once($this->path);
        $class = $this->getClassName($this->path, $declaredClasses);
        if (!$class) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
            throw new NoClassInFileException();
        }
        try {
            $this->refl = new \ReflectionClass($class);
        } catch (\ReflectionException $e) {
            throw new \InvalidArgumentException("Unable to instantiate ReflectionClass. " . $class . " not found in: " . $srcPath);
        }
    }

    /**
     * Returns the fully constructed class
     * with methods or null if the class is abstract
     *
     * @return null|ParsedClass
     */
    public function getClass()
    {
        return ($this->refl->isAbstract())
            ? null
            : new ParsedClass(
                $this->refl->getDocComment(),
                $this->getCleanReflectionName(),
                $this->refl->getNamespaceName(),
                $this->getMethods()
            );
    }

    /**
     * Return reflection name with null bytes stripped
     *
     * @return string
     */
    private function getCleanReflectionName()
    {
        return str_replace("\x00", '', $this->refl->getName());
    }

    /**
     * Return all test methods present in the file
     *
     * @return array
     */
    private function getMethods()
    {
        $tests = [];
        $methods = $this->refl->getMethods(\ReflectionMethod::IS_PUBLIC);
        foreach ($methods as $method) {
            $hasTestName = preg_match(self::$testName, $method->getName());
            $hasTestAnnotation = preg_match(self::$testAnnotation, $method->getDocComment());
            $isTestMethod = $hasTestName || $hasTestAnnotation;
            if ($isTestMethod) {
                $tests[] = new ParsedFunction($method->getDocComment(), 'public', $method->getName());
            }
        }
        return $tests;
    }

    /**
     * Return the class name of the class contained
     * in the file
     *
     * @return string
     */
    private function getClassName($filename, $previousDeclaredClasses)
    {
        $filename = realpath($filename);
        $classes = get_declared_classes();
        $newClasses = array_values(array_diff($classes, $previousDeclaredClasses));

        $className = $this->_searchForUnitTestClass($newClasses, $filename);
        if (isset($className)) {
            return $className;
        }

        $className = $this->_searchForUnitTestClass($classes, $filename);
        if (isset($className)) {
            return $className;
        }
    }

    /**
     * Search for the name of the unit test
     * @param string[] $classes
     * @param string $filename
     * @return string|null
     */
    private function _searchForUnitTestClass(array $classes, $filename) {
        // TODO: After merging this PR or other PR for phpunit 6 support, keep only the applicable subclass name
        $matchingClassName = null;
        foreach ($classes as $className) {
            $class = new \ReflectionClass($className);
            if ($class->getFileName() == $filename) {
                if ($class->isSubclassOf('PHPUnit\Framework\TestCase')) {
                    if ($this->classNameMatchesFileName($filename, $className)) {
                        return $className;
                    } else if ($matchingClassName === null) {
                        $matchingClassName = $className;
                    }
                }
            }
        }
        return $matchingClassName;
    }

    /**
     * @param $filename
     * @param $className
     * @return bool
     */
    private function classNameMatchesFileName($filename, $className)
    {
        return strpos($filename, $className) !== false
            || strpos($filename, $this->invertSlashes($className)) !== false;
    }

    private function invertSlashes($className)
    {
        return str_replace('\\', '/', $className);
    }
}


1		<?php
2		namespace ParaTest\Parser;
3
4		class Parser
5		{
6		/**
7		* The path to the source file to parse
8		*
9		* @var string
10		*/
11		private $path;
12
13		/**
14		* @var \ReflectionClass
15		*/
16		private $refl;
17
18		/**
19		* Matches a test method beginning with the conventional "test"
20		* word
21		*
22		* @var string
23		*/
24		private static $testName = '/^test/';
25
26		/**
27		* A pattern for matching test methods that use the @test annotation
28		*
29		* @var string
30		*/
31		private static $testAnnotation = '/@test\b/';
32
33	31	public function __construct($srcPath)
34		{
35	31	if (!file_exists($srcPath)) {
36	1	throw new \InvalidArgumentException("file not found: " . $srcPath);
37		}
38
39	30	$this->path = $srcPath;
40	30	$declaredClasses = get_declared_classes();
41	30	require_once($this->path);
42	30	$class = $this->getClassName($this->path, $declaredClasses);
43	30	if (!$class) {
		0 ignored issues – show Bug Best Practice introduced 2017-06-07 21:12 UTC by Report Bug Copy Issue Report The expression `$class` of type `string\|null` is loosely compared to `false`; this is ambiguous if the string can be empty. You might want to explicitly use `=== null` instead. In PHP, under loose comparison (like `==`, or `!=`, or `switch` conditions), values of different types might be equal. For `string` values, the empty string `''` is a special case, in particular the following results might be unexpected: '' == false // true '' == null // true 'ab' == false // false 'ab' == null // false // It is often better to use strict comparison '' === false // false '' === null // false Loading history...
44	2	throw new NoClassInFileException();
45		}
46		try {
47	28	$this->refl = new \ReflectionClass($class);
48		} catch (\ReflectionException $e) {
49		throw new \InvalidArgumentException("Unable to instantiate ReflectionClass. " . $class . " not found in: " . $srcPath);
50		}
51	28	}
52
53		/**
54		* Returns the fully constructed class
55		* with methods or null if the class is abstract
56		*
57		* @return null\|ParsedClass
58		*/
59	28	public function getClass()
60		{
61	28	return ($this->refl->isAbstract())
62		? null
63	28	: new ParsedClass(
64	28	$this->refl->getDocComment(),
65	28	$this->getCleanReflectionName(),
66	28	$this->refl->getNamespaceName(),
67	28	$this->getMethods()
68		);
69		}
70
71		/**
72		* Return reflection name with null bytes stripped
73		*
74		* @return string
75		*/
76	28	private function getCleanReflectionName()
77		{
78	28	return str_replace("\x00", '', $this->refl->getName());
79		}
80
81		/**
82		* Return all test methods present in the file
83		*
84		* @return array
85		*/
86	28	private function getMethods()
87		{
88	28	$tests = [];
89	28	$methods = $this->refl->getMethods(\ReflectionMethod::IS_PUBLIC);
90	28	foreach ($methods as $method) {
91	28	$hasTestName = preg_match(self::$testName, $method->getName());
92	28	$hasTestAnnotation = preg_match(self::$testAnnotation, $method->getDocComment());
93	28	$isTestMethod = $hasTestName \|\| $hasTestAnnotation;
94	28	if ($isTestMethod) {
95	28	$tests[] = new ParsedFunction($method->getDocComment(), 'public', $method->getName());
96		}
97		}
98	28	return $tests;
99		}
100
101		/**
102		* Return the class name of the class contained
103		* in the file
104		*
105		* @return string
106		*/
107	30	private function getClassName($filename, $previousDeclaredClasses)
108		{
109	30	$filename = realpath($filename);
110	30	$classes = get_declared_classes();
111	30	$newClasses = array_values(array_diff($classes, $previousDeclaredClasses));
112
113	30	$className = $this->_searchForUnitTestClass($newClasses, $filename);
114	30	if (isset($className)) {
115	12	return $className;
116		}
117
118	22	$className = $this->_searchForUnitTestClass($classes, $filename);
119	22	if (isset($className)) {
120	20	return $className;
121		}
122	2	}
123
124		/**
125		* Search for the name of the unit test
126		* @param string[] $classes
127		* @param string $filename
128		* @return string\|null
129		*/
130	30	private function _searchForUnitTestClass(array $classes, $filename) {
131		// TODO: After merging this PR or other PR for phpunit 6 support, keep only the applicable subclass name
132	30	$matchingClassName = null;
133	30	foreach ($classes as $className) {
134	30	$class = new \ReflectionClass($className);
135	30	if ($class->getFileName() == $filename) {
136	28	if ($class->isSubclassOf('PHPUnit\Framework\TestCase')) {
137	28	if ($this->classNameMatchesFileName($filename, $className)) {
138	21	return $className;
139	18	} else if ($matchingClassName === null) {
140	27	$matchingClassName = $className;
141		}
142		}
143		}
144		}
145	25	return $matchingClassName;
146		}
147
148		/**
149		* @param $filename
150		* @param $className
151		* @return bool
152		*/
153	28	private function classNameMatchesFileName($filename, $className)
154		{
155	28	return strpos($filename, $className) !== false
156	28	\|\| strpos($filename, $this->invertSlashes($className)) !== false;
157		}
158
159	18	private function invertSlashes($className)
160		{
161	18	return str_replace('\\', '/', $className);
162		}
163		}
164

brianium / paratest

Push — master ( cd00cd...086849 )

Parser::getClass() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like