Add covers annotation support

composer.json

@@ -47,11 +47,13 @@
     },
     "require-dev": {
         "drupol/php-conventions": "^3.0",
+        "sebastian/code-unit": "^1.0.8",
         "vimeo/psalm": "^4.7"
     },
     "suggest": {
         "ext-pcov": "Install PCov extension to generate code coverage.",
-        "ext-xdebug": "Install Xdebug to generate phpspec code coverage."
+        "ext-xdebug": "Install Xdebug to generate phpspec code coverage.",
+        "sebastian/code-unit": "Install code-unit to support @covers annotations in tests."
     },
     "extra": {
         "branch-alias": {

docker-compose.yml

@@ -0,0 +1,11 @@
+version: '3.2'
+services:
+  php:
+    build:
+      context: ./
+      dockerfile: docker/Dockerfile
+    tty: true
+    hostname: phpspec-code-coverage-php
+    container_name: phpspec-code-coverage-php
+    volumes:
+      - ./:/var/www/html

docker/Dockerfile

@@ -0,0 +1,15 @@
+FROM php:7.3-cli-alpine3.12
+
+# SYS: Install required packages
+RUN apk --no-cache upgrade && \
+    apk --no-cache add bash git sudo openssh autoconf gcc g++ make gettext make
+
+# COMPOSER: install binary
+RUN curl -sS https://getcomposer.org/installer | php -- --install-dir=/usr/bin --filename=composer
+
+# PHP: Install php extensions
+RUN pecl channel-update pecl.php.net && \
+    pecl install pcov && \
+    docker-php-ext-enable pcov
+
+WORKDIR /var/www/html

spec/Listener/CodeCoverageListenerSpec.php

@@ -90,7 +90,7 @@ public function let(ConsoleIO $io)
     {
         $codeCoverage = new CodeCoverage(new DriverStub(), new Filter());
 
-        $this->beConstructedWith($io, $codeCoverage, []);
+        $this->beConstructedWith($io, $codeCoverage, null, []);
     }
 }
 

src/Annotation/CoversAnnotationUtil.php

@@ -0,0 +1,191 @@
+<?php
+
+declare(strict_types=1);
+
+namespace FriendsOfPhpSpec\PhpSpec\CodeCoverage\Annotation;
+
+use FriendsOfPhpSpec\PhpSpec\CodeCoverage\Exception\CodeCoverageException;
+use FriendsOfPhpSpec\PhpSpec\CodeCoverage\Exception\InvalidCoversTargetException;
+use ReflectionException;
+use SebastianBergmann\CodeUnit\CodeUnitCollection;
+use SebastianBergmann\CodeUnit\InvalidCodeUnitException;
+use SebastianBergmann\CodeUnit\Mapper;
+
+use function count;
+
+final class CoversAnnotationUtil
+{
+    /**
+     * @var Registry
+     */
+    private $registry;
+
+    public function __construct(Registry $registry)
+    {
+        $this->registry = $registry;
+    }
+
+    /**
+     * @param class-string $className
+     *
+     * @throws CodeCoverageException
+     * @throws InvalidCoversTargetException
+     * @throws ReflectionException
+     *
+     * @return array<string, array>|false
+     */
+    public function getLinesToBeCovered(string $className, string $methodName)
+    {
+        $annotations = $this->parseTestMethodAnnotations(
+            $className,
+            $methodName
+        );
+
+        if (!$this->shouldCoversAnnotationBeUsed($annotations)) {
+            return false;
+        }
+
+        return $this->getLinesToBeCoveredOrUsed($className, $methodName, 'covers');
+    }
+
+    /**
+     * Returns lines of code specified with the.
+     *
+     * @param class-string $className .
+     *
+     * @throws CodeCoverageException
+     * @throws InvalidCoversTargetException
+     * @throws ReflectionException
+     *
+     * @return array<string, array>
+     *
+     * @uses annotation.
+     */
+    public function getLinesToBeUsed(string $className, string $methodName): array
+    {
+        return $this->getLinesToBeCoveredOrUsed($className, $methodName, 'uses');
+    }
+
+    /**
+     * @param class-string $className
+     *
+     * @throws ReflectionException
+     *
+     * @return array<string, mixed>
+     */
+    public function parseTestMethodAnnotations(string $className, ?string $methodName = ''): array
+    {
+        if (null !== $methodName) {
+            try {
+                return [
+                    'method' => $this->registry->forMethod($className, $methodName)->symbolAnnotations(),
+                    'class' => $this->registry->forClassName($className)->symbolAnnotations(),
+                ];
+            } catch (ReflectionException $methodNotFound) {
+                // ignored
+            }
+        }
+
+        return [
+            'method' => null,
+            'class' => $this->registry->forClassName($className)->symbolAnnotations(),
+        ];
+    }
+
+    /**
+     * @param class-string $className
+     *
+     * @throws CodeCoverageException
+     * @throws InvalidCoversTargetException
+     * @throws ReflectionException
+     *
+     * @return array<string, array>
+     */
+    private function getLinesToBeCoveredOrUsed(string $className, string $methodName, string $mode): array
+    {
+        $annotations = $this->parseTestMethodAnnotations(
+            $className,
+            $methodName
+        );
+
+        $classShortcut = null;
+
+        if (!empty($annotations['class'][$mode . 'DefaultClass'])) {
+            if (count($annotations['class'][$mode . 'DefaultClass']) > 1) {
+                throw new CodeCoverageException(
+                    sprintf(
+                        'More than one @%sClass annotation in class or interface "%s".',
+                        $mode,
+                        $className
+                    )
+                );
+            }
+
+            $classShortcut = $annotations['class'][$mode . 'DefaultClass'][0];
+        }
+
+        $list = $annotations['class'][$mode] ?? [];
+
+        if (isset($annotations['method'][$mode])) {
+            $list = array_merge($list, $annotations['method'][$mode]);
+        }
+
+        $codeUnits = CodeUnitCollection::fromArray([]);
+        $mapper = new Mapper();
+
+        foreach (array_unique($list) as $element) {
+            if ($classShortcut && strncmp($element, '::', 2) === 0) {
+                $element = $classShortcut . $element;
+            }
+
+            $element = preg_replace('/[\s()]+$/', '', $element);
+            $element = explode(' ', $element);
+            $element = $element[0];
+
+            if ('covers' === $mode && interface_exists($element)) {
+                throw new InvalidCoversTargetException(
+                    sprintf(
+                        'Trying to @cover interface "%s".',
+                        $element
+                    )
+                );
+            }
+
+            try {
+                $codeUnits = $codeUnits->mergeWith($mapper->stringToCodeUnits($element));
+            } catch (InvalidCodeUnitException $e) {
+                throw new InvalidCoversTargetException(
+                    sprintf(
+                        '"@%s %s" is invalid',
+                        $mode,
+                        $element
+                    ),
+                    (int) $e->getCode(),
+                    $e
+                );
+            }
+        }
+
+        return $mapper->codeUnitsToSourceLines($codeUnits);
+    }
+
+    /**
+     * @param array<string, array<string, mixed>> $annotations
+     */
+    private function shouldCoversAnnotationBeUsed(array $annotations): bool
+    {
+        if (isset($annotations['method']['coversNothing'])) {
+            return false;
+        }
+
+        if (isset($annotations['method']['covers'])) {
+            return true;
+        }
+
+        if (isset($annotations['class']['coversNothing'])) {
+            return false;
+        }
+
+        return true;
+    }
+}