Rename lineData to lineCoverage

sebastianbergmann · sebastianbergmann · commit d32874c2445a · 2020-05-23T09:57:14.000+02:00
diff --git a/src/CodeCoverage.php b/src/CodeCoverage.php
@@ -312,7 +312,7 @@ public function append(RawCodeCoverageData $rawData, $id = null, bool $append =
             );
         }
 
-        if (empty($rawData->getLineData())) {
+        if (empty($rawData->getLineCoverage())) {
             return;
         }
 
@@ -339,7 +339,7 @@ public function append(RawCodeCoverageData $rawData, $id = null, bool $append =
 
         $this->tests[$id] = ['size' => $size, 'status' => $status];
 
-        foreach ($rawData->getLineData() as $file => $lines) {
+        foreach ($rawData->getLineCoverage() as $file => $lines) {
             if (!$this->filter->isFile($file)) {
                 continue;
             }
@@ -526,7 +526,7 @@ private function applyCoversAnnotationFilter(RawCodeCoverageData $rawData, $line
             $this->performUnexecutedCoveredCodeCheck($rawData, $linesToBeCovered, $linesToBeUsed);
         }
 
-        $rawLineData         = $rawData->getLineData();
+        $rawLineData         = $rawData->getLineCoverage();
         $filesWithNoCoverage = \array_diff_key($rawLineData, $linesToBeCovered);
 
         foreach (\array_keys($filesWithNoCoverage) as $fileWithNoCoverage) {
@@ -542,7 +542,7 @@ private function applyCoversAnnotationFilter(RawCodeCoverageData $rawData, $line
 
     private function applyWhitelistFilter(RawCodeCoverageData $data): void
     {
-        foreach (\array_keys($data->getLineData()) as $filename) {
+        foreach (\array_keys($data->getLineCoverage()) as $filename) {
             if ($this->filter->isFiltered($filename)) {
                 $data->removeCoverageDataForFile($filename);
             }
@@ -554,14 +554,14 @@ private function applyWhitelistFilter(RawCodeCoverageData $data): void
      */
     private function applyIgnoredLinesFilter(RawCodeCoverageData $data): void
     {
-        foreach (\array_keys($data->getLineData()) as $filename) {
+        foreach (\array_keys($data->getLineCoverage()) as $filename) {
             $data->removeCoverageDataForLines($filename, $this->getLinesToBeIgnored($filename));
         }
     }
 
     private function initializeFilesThatAreSeenTheFirstTime(RawCodeCoverageData $data): void
     {
-        foreach ($data->getLineData() as $file => $lines) {
+        foreach ($data->getLineCoverage() as $file => $lines) {
             if (!isset($this->data[$file]) && $this->filter->isFile($file)) {
                 $this->data[$file] = [];
 
@@ -802,7 +802,7 @@ private function performUnintentionallyCoveredCodeCheck(RawCodeCoverageData $dat
 
         $unintentionallyCoveredUnits = [];
 
-        foreach ($data->getLineData() as $file => $_data) {
+        foreach ($data->getLineCoverage() as $file => $_data) {
             foreach ($_data as $line => $flag) {
                 if ($flag === 1 && !isset($allowedLines[$file][$line])) {
                     $unintentionallyCoveredUnits[] = $this->wizard->lookup($file, $line);
@@ -958,7 +958,7 @@ private function initializeData(): void
 
             $data = [];
 
-            foreach ($this->driver->stop()->getLineData() as $file => $fileCoverage) {
+            foreach ($this->driver->stop()->getLineCoverage() as $file => $fileCoverage) {
                 if ($this->filter->isFiltered($file)) {
                     continue;
                 }
@@ -980,7 +980,7 @@ private function coverageToCodeUnits(RawCodeCoverageData $rawData): array
     {
         $codeUnits = [];
 
-        foreach ($rawData->getLineData() as $filename => $lines) {
+        foreach ($rawData->getLineCoverage() as $filename => $lines) {
             foreach ($lines as $line => $flag) {
                 if ($flag === 1) {
                     $codeUnits[] = $this->wizard->lookup($filename, $line);
diff --git a/src/RawCodeCoverageData.php b/src/RawCodeCoverageData.php
@@ -15,23 +15,21 @@
 final class RawCodeCoverageData
 {
     /**
-     * Line coverage data.
+     * @var array
      *
      * @see https://xdebug.org/docs/code_coverage for format
-     *
-     * @var array
      */
-    private $lineData = [];
+    private $lineCoverage = [];
 
     public function __construct(array $rawCoverage = [])
     {
         foreach ($rawCoverage as $file => $fileCoverageData) {
             $hasOnlyIntegerKeys = \count(\array_filter(\array_keys($fileCoverageData), 'is_int')) === \count($fileCoverageData);
 
             if ($hasOnlyIntegerKeys) {
-                $this->lineData[$file] = $fileCoverageData;
+                $this->lineCoverage[$file] = $fileCoverageData;
             } elseif (\count($fileCoverageData) === 2 && isset($fileCoverageData['lines'], $fileCoverageData['functions'])) {
-                $this->lineData[$file] = $fileCoverageData['lines'];
+                $this->lineCoverage[$file] = $fileCoverageData['lines'];
             } else {
                 throw UnknownCoverageDataFormatException::create($file);
             }
@@ -40,32 +38,38 @@ public function __construct(array $rawCoverage = [])
 
     public function clear(): void
     {
-        $this->lineData = [];
+        $this->lineCoverage = [];
     }
 
-    public function getLineData(): array
+    public function getLineCoverage(): array
     {
-        return $this->lineData;
+        return $this->lineCoverage;
     }
 
     public function removeCoverageDataForFile(string $filename): void
     {
-        unset($this->lineData[$filename]);
+        unset($this->lineCoverage[$filename]);
     }
 
     /**
      * @param int[] $lines
      */
     public function keepCoverageDataOnlyForLines(string $filename, array $lines): void
     {
-        $this->lineData[$filename] = \array_intersect_key($this->lineData[$filename], \array_flip($lines));
+        $this->lineCoverage[$filename] = \array_intersect_key(
+            $this->lineCoverage[$filename],
+            \array_flip($lines)
+        );
     }
 
     /**
      * @param int[] $lines
      */
     public function removeCoverageDataForLines(string $filename, array $lines): void
     {
-        $this->lineData[$filename] = \array_diff_key($this->lineData[$filename], \array_flip($lines));
+        $this->lineCoverage[$filename] = \array_diff_key(
+            $this->lineCoverage[$filename],
+            \array_flip($lines)
+        );
     }
 }
diff --git a/tests/tests/RawCodeCoverageDataTest.php b/tests/tests/RawCodeCoverageDataTest.php
@@ -25,7 +25,7 @@ public function testLineDataFromStandardXDebugFormat(): void
         ];
 
         $dataObject = new RawCodeCoverageData($lineDataFromDriver);
-        $this->assertEquals($lineDataFromDriver, $dataObject->getLineData());
+        $this->assertEquals($lineDataFromDriver, $dataObject->getLineCoverage());
     }
 
     /**
@@ -55,7 +55,7 @@ public function testLineDataFromBranchCheckXDebugFormat(): void
         ];
 
         $dataObject = new RawCodeCoverageData($rawDataFromDriver);
-        $this->assertEquals($lineData, $dataObject->getLineData());
+        $this->assertEquals($lineData, $dataObject->getLineCoverage());
     }
 
     /**
@@ -94,7 +94,7 @@ public function testClear(): void
 
         $dataObject = new RawCodeCoverageData($lineDataFromDriver);
         $dataObject->clear();
-        $this->assertEmpty($dataObject->getLineData());
+        $this->assertEmpty($dataObject->getLineCoverage());
     }
 
     public function testRemoveCoverageDataForFile(): void
@@ -132,7 +132,7 @@ public function testRemoveCoverageDataForFile(): void
 
         $dataObject = new RawCodeCoverageData($lineDataFromDriver);
         $dataObject->removeCoverageDataForFile('/some/path/SomeOtherClass.php');
-        $this->assertEquals($expectedFilterResult, $dataObject->getLineData());
+        $this->assertEquals($expectedFilterResult, $dataObject->getLineCoverage());
     }
 
     public function testKeepCoverageDataOnlyForLines(): void
@@ -171,7 +171,7 @@ public function testKeepCoverageDataOnlyForLines(): void
         $dataObject->keepCoverageDataOnlyForLines('/some/path/SomeClass.php', [9, 13]);
         $dataObject->keepCoverageDataOnlyForLines('/some/path/SomeOtherClass.php', [999]);
         $dataObject->keepCoverageDataOnlyForLines('/some/path/AnotherClass.php', [28]);
-        $this->assertEquals($expectedFilterResult, $dataObject->getLineData());
+        $this->assertEquals($expectedFilterResult, $dataObject->getLineCoverage());
     }
 
     public function testRemoveCoverageDataForLines(): void
@@ -213,6 +213,6 @@ public function testRemoveCoverageDataForLines(): void
         $dataObject->removeCoverageDataForLines('/some/path/SomeClass.php', [9, 13]);
         $dataObject->removeCoverageDataForLines('/some/path/SomeOtherClass.php', [999]);
         $dataObject->removeCoverageDataForLines('/some/path/AnotherClass.php', [28]);
-        $this->assertEquals($expectedFilterResult, $dataObject->getLineData());
+        $this->assertEquals($expectedFilterResult, $dataObject->getLineCoverage());
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -312,7 +312,7 @@ public function append(RawCodeCoverageData $rawData, $id = null, bool $append =`
`312`	`312`	`);`
`313`	`313`	`}`
`314`	`314`
`315`		`- if (empty($rawData->getLineData())) {`
	`315`	`+ if (empty($rawData->getLineCoverage())) {`
`316`	`316`	`return;`
`317`	`317`	`}`
`318`	`318`
`@@ -339,7 +339,7 @@ public function append(RawCodeCoverageData $rawData, $id = null, bool $append =`
`339`	`339`
`340`	`340`	`$this->tests[$id] = ['size' => $size, 'status' => $status];`
`341`	`341`
`342`		`- foreach ($rawData->getLineData() as $file => $lines) {`
	`342`	`+ foreach ($rawData->getLineCoverage() as $file => $lines) {`
`343`	`343`	`if (!$this->filter->isFile($file)) {`
`344`	`344`	`continue;`
`345`	`345`	`}`
`@@ -526,7 +526,7 @@ private function applyCoversAnnotationFilter(RawCodeCoverageData $rawData, $line`
`526`	`526`	`$this->performUnexecutedCoveredCodeCheck($rawData, $linesToBeCovered, $linesToBeUsed);`
`527`	`527`	`}`
`528`	`528`
`529`		`- $rawLineData = $rawData->getLineData();`
	`529`	`+ $rawLineData = $rawData->getLineCoverage();`
`530`	`530`	`$filesWithNoCoverage = \array_diff_key($rawLineData, $linesToBeCovered);`
`531`	`531`
`532`	`532`	`foreach (\array_keys($filesWithNoCoverage) as $fileWithNoCoverage) {`
`@@ -542,7 +542,7 @@ private function applyCoversAnnotationFilter(RawCodeCoverageData $rawData, $line`
`542`	`542`
`543`	`543`	`private function applyWhitelistFilter(RawCodeCoverageData $data): void`
`544`	`544`	`{`
`545`		`- foreach (\array_keys($data->getLineData()) as $filename) {`
	`545`	`+ foreach (\array_keys($data->getLineCoverage()) as $filename) {`
`546`	`546`	`if ($this->filter->isFiltered($filename)) {`
`547`	`547`	`$data->removeCoverageDataForFile($filename);`
`548`	`548`	`}`
`@@ -554,14 +554,14 @@ private function applyWhitelistFilter(RawCodeCoverageData $data): void`
`554`	`554`	`*/`
`555`	`555`	`private function applyIgnoredLinesFilter(RawCodeCoverageData $data): void`
`556`	`556`	`{`
`557`		`- foreach (\array_keys($data->getLineData()) as $filename) {`
	`557`	`+ foreach (\array_keys($data->getLineCoverage()) as $filename) {`
`558`	`558`	`$data->removeCoverageDataForLines($filename, $this->getLinesToBeIgnored($filename));`
`559`	`559`	`}`
`560`	`560`	`}`
`561`	`561`
`562`	`562`	`private function initializeFilesThatAreSeenTheFirstTime(RawCodeCoverageData $data): void`
`563`	`563`	`{`
`564`		`- foreach ($data->getLineData() as $file => $lines) {`
	`564`	`+ foreach ($data->getLineCoverage() as $file => $lines) {`
`565`	`565`	`if (!isset($this->data[$file]) && $this->filter->isFile($file)) {`
`566`	`566`	`$this->data[$file] = [];`
`567`	`567`
`@@ -802,7 +802,7 @@ private function performUnintentionallyCoveredCodeCheck(RawCodeCoverageData $dat`
`802`	`802`
`803`	`803`	`$unintentionallyCoveredUnits = [];`
`804`	`804`
`805`		`- foreach ($data->getLineData() as $file => $_data) {`
	`805`	`+ foreach ($data->getLineCoverage() as $file => $_data) {`
`806`	`806`	`foreach ($_data as $line => $flag) {`
`807`	`807`	`if ($flag === 1 && !isset($allowedLines[$file][$line])) {`
`808`	`808`	`$unintentionallyCoveredUnits[] = $this->wizard->lookup($file, $line);`
`@@ -958,7 +958,7 @@ private function initializeData(): void`
`958`	`958`
`959`	`959`	`$data = [];`
`960`	`960`
`961`		`- foreach ($this->driver->stop()->getLineData() as $file => $fileCoverage) {`
	`961`	`+ foreach ($this->driver->stop()->getLineCoverage() as $file => $fileCoverage) {`
`962`	`962`	`if ($this->filter->isFiltered($file)) {`
`963`	`963`	`continue;`
`964`	`964`	`}`
`@@ -980,7 +980,7 @@ private function coverageToCodeUnits(RawCodeCoverageData $rawData): array`
`980`	`980`	`{`
`981`	`981`	`$codeUnits = [];`
`982`	`982`
`983`		`- foreach ($rawData->getLineData() as $filename => $lines) {`
	`983`	`+ foreach ($rawData->getLineCoverage() as $filename => $lines) {`
`984`	`984`	`foreach ($lines as $line => $flag) {`
`985`	`985`	`if ($flag === 1) {`
`986`	`986`	`$codeUnits[] = $this->wizard->lookup($filename, $line);`
Original file line number	Diff line number	Diff line change
`@@ -15,23 +15,21 @@`
`15`	`15`	`final class RawCodeCoverageData`
`16`	`16`	`{`
`17`	`17`	`/**`
`18`		`- * Line coverage data.`
	`18`	`+ * @var array`
`19`	`19`	`*`
`20`	`20`	`* @see https://xdebug.org/docs/code_coverage for format`
`21`		`- *`
`22`		`- * @var array`
`23`	`21`	`*/`
`24`		`- private $lineData = [];`
	`22`	`+ private $lineCoverage = [];`
`25`	`23`
`26`	`24`	`public function __construct(array $rawCoverage = [])`
`27`	`25`	`{`
`28`	`26`	`foreach ($rawCoverage as $file => $fileCoverageData) {`
`29`	`27`	`$hasOnlyIntegerKeys = \count(\array_filter(\array_keys($fileCoverageData), 'is_int')) === \count($fileCoverageData);`
`30`	`28`
`31`	`29`	`if ($hasOnlyIntegerKeys) {`
`32`		`- $this->lineData[$file] = $fileCoverageData;`
	`30`	`+ $this->lineCoverage[$file] = $fileCoverageData;`
`33`	`31`	`} elseif (\count($fileCoverageData) === 2 && isset($fileCoverageData['lines'], $fileCoverageData['functions'])) {`
`34`		`- $this->lineData[$file] = $fileCoverageData['lines'];`
	`32`	`+ $this->lineCoverage[$file] = $fileCoverageData['lines'];`
`35`	`33`	`} else {`
`36`	`34`	`throw UnknownCoverageDataFormatException::create($file);`
`37`	`35`	`}`
`@@ -40,32 +38,38 @@ public function __construct(array $rawCoverage = [])`
`40`	`38`
`41`	`39`	`public function clear(): void`
`42`	`40`	`{`
`43`		`- $this->lineData = [];`
	`41`	`+ $this->lineCoverage = [];`
`44`	`42`	`}`
`45`	`43`
`46`		`- public function getLineData(): array`
	`44`	`+ public function getLineCoverage(): array`
`47`	`45`	`{`
`48`		`- return $this->lineData;`
	`46`	`+ return $this->lineCoverage;`
`49`	`47`	`}`
`50`	`48`
`51`	`49`	`public function removeCoverageDataForFile(string $filename): void`
`52`	`50`	`{`
`53`		`- unset($this->lineData[$filename]);`
	`51`	`+ unset($this->lineCoverage[$filename]);`
`54`	`52`	`}`
`55`	`53`
`56`	`54`	`/**`
`57`	`55`	`* @param int[] $lines`
`58`	`56`	`*/`
`59`	`57`	`public function keepCoverageDataOnlyForLines(string $filename, array $lines): void`
`60`	`58`	`{`
`61`		`- $this->lineData[$filename] = \array_intersect_key($this->lineData[$filename], \array_flip($lines));`
	`59`	`+ $this->lineCoverage[$filename] = \array_intersect_key(`
	`60`	`+ $this->lineCoverage[$filename],`
	`61`	`+ \array_flip($lines)`
	`62`	`+ );`
`62`	`63`	`}`
`63`	`64`
`64`	`65`	`/**`
`65`	`66`	`* @param int[] $lines`
`66`	`67`	`*/`
`67`	`68`	`public function removeCoverageDataForLines(string $filename, array $lines): void`
`68`	`69`	`{`
`69`		`- $this->lineData[$filename] = \array_diff_key($this->lineData[$filename], \array_flip($lines));`
	`70`	`+ $this->lineCoverage[$filename] = \array_diff_key(`
	`71`	`+ $this->lineCoverage[$filename],`
	`72`	`+ \array_flip($lines)`
	`73`	`+ );`
`70`	`74`	`}`
`71`	`75`	`}`
Original file line number	Diff line number	Diff line change
`@@ -25,7 +25,7 @@ public function testLineDataFromStandardXDebugFormat(): void`
`25`	`25`	`];`
`26`	`26`
`27`	`27`	`$dataObject = new RawCodeCoverageData($lineDataFromDriver);`
`28`		`- $this->assertEquals($lineDataFromDriver, $dataObject->getLineData());`
	`28`	`+ $this->assertEquals($lineDataFromDriver, $dataObject->getLineCoverage());`
`29`	`29`	`}`
`30`	`30`
`31`	`31`	`/**`
`@@ -55,7 +55,7 @@ public function testLineDataFromBranchCheckXDebugFormat(): void`
`55`	`55`	`];`
`56`	`56`
`57`	`57`	`$dataObject = new RawCodeCoverageData($rawDataFromDriver);`
`58`		`- $this->assertEquals($lineData, $dataObject->getLineData());`
	`58`	`+ $this->assertEquals($lineData, $dataObject->getLineCoverage());`
`59`	`59`	`}`
`60`	`60`
`61`	`61`	`/**`
`@@ -94,7 +94,7 @@ public function testClear(): void`
`94`	`94`
`95`	`95`	`$dataObject = new RawCodeCoverageData($lineDataFromDriver);`
`96`	`96`	`$dataObject->clear();`
`97`		`- $this->assertEmpty($dataObject->getLineData());`
	`97`	`+ $this->assertEmpty($dataObject->getLineCoverage());`
`98`	`98`	`}`
`99`	`99`
`100`	`100`	`public function testRemoveCoverageDataForFile(): void`
`@@ -132,7 +132,7 @@ public function testRemoveCoverageDataForFile(): void`
`132`	`132`
`133`	`133`	`$dataObject = new RawCodeCoverageData($lineDataFromDriver);`
`134`	`134`	`$dataObject->removeCoverageDataForFile('/some/path/SomeOtherClass.php');`
`135`		`- $this->assertEquals($expectedFilterResult, $dataObject->getLineData());`
	`135`	`+ $this->assertEquals($expectedFilterResult, $dataObject->getLineCoverage());`
`136`	`136`	`}`
`137`	`137`
`138`	`138`	`public function testKeepCoverageDataOnlyForLines(): void`
`@@ -171,7 +171,7 @@ public function testKeepCoverageDataOnlyForLines(): void`
`171`	`171`	`$dataObject->keepCoverageDataOnlyForLines('/some/path/SomeClass.php', [9, 13]);`
`172`	`172`	`$dataObject->keepCoverageDataOnlyForLines('/some/path/SomeOtherClass.php', [999]);`
`173`	`173`	`$dataObject->keepCoverageDataOnlyForLines('/some/path/AnotherClass.php', [28]);`
`174`		`- $this->assertEquals($expectedFilterResult, $dataObject->getLineData());`
	`174`	`+ $this->assertEquals($expectedFilterResult, $dataObject->getLineCoverage());`
`175`	`175`	`}`
`176`	`176`
`177`	`177`	`public function testRemoveCoverageDataForLines(): void`
`@@ -213,6 +213,6 @@ public function testRemoveCoverageDataForLines(): void`
`213`	`213`	`$dataObject->removeCoverageDataForLines('/some/path/SomeClass.php', [9, 13]);`
`214`	`214`	`$dataObject->removeCoverageDataForLines('/some/path/SomeOtherClass.php', [999]);`
`215`	`215`	`$dataObject->removeCoverageDataForLines('/some/path/AnotherClass.php', [28]);`
`216`		`- $this->assertEquals($expectedFilterResult, $dataObject->getLineData());`
	`216`	`+ $this->assertEquals($expectedFilterResult, $dataObject->getLineCoverage());`
`217`	`217`	`}`
`218`	`218`	`}`