improve trait spotting to use single object (#77)

Author: TomasVotruba

README.md

@@ -271,6 +271,27 @@ vendor/bin/swiss-knife generate-symfony-config-builders
 
 That way IDE, PHPStan after adding those paths and Rector can understand your config files better.
 
+<br>
+
+## 11. Spots Fake Traits
+
+What is trait has 5 lines and used in single service? We know it's better to e inlined, to empower IDE, Rector and PHPStan. But don't have time to worry about these details.
+
+We made a command to automate this process and spot the traits most likely to be inlined:
+
+```bash
+vendor/bin/swiss-knife spot-lazy-traits src
+```
+
+By default, the commands look for traits used max 2-times. To change that:
+
+```bash
+vendor/bin/swiss-knife spot-lazy-traits src --max-used 4
+```
+
+That's it! Run this command once upon a time or run it in CI to eliminate traits with low value to exists. Your code will be more robuts and easier to work with.
+
+
 <br>
 
 Happy coding!

src/Command/SpotLazyTraitsCommand.php

@@ -0,0 +1,89 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Rector\SwissKnife\Command;
+
+use Rector\SwissKnife\Traits\TraitSpotter;
+use Symfony\Component\Console\Command\Command;
+use Symfony\Component\Console\Input\InputArgument;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Input\InputOption;
+use Symfony\Component\Console\Output\OutputInterface;
+use Symfony\Component\Console\Style\SymfonyStyle;
+
+final class SpotLazyTraitsCommand extends Command
+{
+    public function __construct(
+        private readonly SymfonyStyle $symfonyStyle,
+        private readonly TraitSpotter $traitSpotter,
+    ) {
+        parent::__construct();
+    }
+
+    protected function configure(): void
+    {
+        $this->setName('spot-lazy-traits');
+
+        $this->addArgument(
+            'sources',
+            InputArgument::REQUIRED | InputArgument::IS_ARRAY,
+            'One or more paths to check'
+        );
+
+        $this->addOption('max-used', null, InputOption::VALUE_REQUIRED, 'Maximum count the trait is used', 2);
+
+        $this->setDescription(
+            'Spot traits that are use only once, to potentially inline them and make code more robust and readable'
+        );
+    }
+
+    protected function execute(InputInterface $input, OutputInterface $output): int
+    {
+        $sources = (array) $input->getArgument('sources');
+        $maxUsedCount = (int) $input->getOption('max-used');
+
+        $this->symfonyStyle->title('Looking for trait definitions');
+        $traitSpottingResult = $this->traitSpotter->analyse($sources);
+
+        if ($traitSpottingResult->getTraitCount() === 0) {
+            $this->symfonyStyle->success('No traits were found in your project, nothing to worry about');
+            return self::SUCCESS;
+        }
+
+        $this->symfonyStyle->writeln(
+            sprintf(
+                'Found %d trait%s in the whole project',
+                $traitSpottingResult->getTraitCount(),
+                $traitSpottingResult->getTraitCount() === 1 ? '' : 's'
+            )
+        );
+        $this->symfonyStyle->listing($traitSpottingResult->getTraitFilePaths());
+
+        $this->symfonyStyle->newLine();
+
+        $this->symfonyStyle->title(sprintf('Looking for traits used less than %d-times', $maxUsedCount));
+
+        $leastUsedTraitsMetadatas = $traitSpottingResult->getTraitMaximumUsedTimes($maxUsedCount);
+
+        foreach ($leastUsedTraitsMetadatas as $leastUsedTraitMetadata) {
+            $this->symfonyStyle->writeln(sprintf(
+                'Trait "%s" (%d lines) is used only in %d file%s',
+                $leastUsedTraitMetadata->getShortTraitName(),
+                $leastUsedTraitMetadata->getLineCount(),
+                $leastUsedTraitMetadata->getUsedInCount(),
+                $leastUsedTraitMetadata->getUsedInCount() === 1 ? '' : 's'
+            ));
+
+            $this->symfonyStyle->listing($leastUsedTraitMetadata->getUsedIn());
+            $this->symfonyStyle->newLine();
+        }
+
+        $this->symfonyStyle->warning(sprintf(
+            'Inline these traits or refactor them to a service if meaningful.%sChange "--max-used" to different number to get more result',
+            PHP_EOL
+        ));
+
+        return self::SUCCESS;
+    }
+}

src/Command/TraitSpottingCommand.php

@@ -4,6 +4,7 @@
 
 namespace Rector\SwissKnife\Finder;
 
+use Nette\Utils\Strings;
 use Symfony\Component\Finder\Finder;
 use Symfony\Component\Finder\SplFileInfo;
 use Webmozart\Assert\Assert;
@@ -48,7 +49,7 @@ public function find(array $directories): array
             ->sortByName()
             ->filter(function (SplFileInfo $fileInfo): bool {
                 $fileContent = $fileInfo->getContents();
-                return str_contains($fileContent, 'trait ');
+                return (bool) Strings::match($fileContent, '#^trait\s#m');
             });
 
         return iterator_to_array($traitFinder->getIterator());

src/Finder/TraitFilesFinder.php

@@ -6,8 +6,8 @@
 
 use Nette\Utils\Strings;
 use Rector\SwissKnife\Finder\TraitFilesFinder;
+use Rector\SwissKnife\ValueObject\Traits\TraitMetadata;
 use Rector\SwissKnife\ValueObject\Traits\TraitSpottingResult;
-use Symfony\Component\Finder\SplFileInfo;
 
 /**
  * @see \Rector\SwissKnife\Tests\Traits\TraitSpotterTest
@@ -26,33 +26,46 @@ public function analyse(array $directories): TraitSpottingResult
     {
         $traitFiles = $this->traitFilesFinder->find($directories);
 
-        $shortNameToLineCount = [];
+        $traitsMetadatas = [];
+
         foreach ($traitFiles as $traitFile) {
             $traitShortName = $traitFile->getBasename('.php');
-            $shortNameToLineCount[$traitShortName] = substr_count($traitFile->getContents(), PHP_EOL);
-        }
 
-        $shortTraitNamesToLineCount = $shortNameToLineCount;
+            $traitsMetadatas[] = new TraitMetadata($traitFile->getRealPath(), $traitShortName);
+        }
 
         $traitUsageFiles = $this->traitFilesFinder->findTraitUsages($directories);
 
-        $usagesToFiles = [];
         foreach ($traitUsageFiles as $traitUsageFile) {
-            $matches = Strings::matchAll($traitUsageFile->getContents(), '#    use (?<short_trait_name>[\w]+);#');
+            $matches = Strings::matchAll($traitUsageFile->getContents(), '#^    use (?<short_trait_name>[\w]+);#m');
 
             foreach ($matches as $match) {
                 $shortTraitName = $match['short_trait_name'];
-                $usagesToFiles[$shortTraitName][] = $this->getRelativeFilePath($traitUsageFile);
+
+                // fuzzy in exchange for speed
+                $currentTraitMetadata = $this->matchTraitByShortName($traitsMetadatas, $shortTraitName);
+                if (! $currentTraitMetadata instanceof TraitMetadata) {
+                    continue;
+                }
+
+                $currentTraitMetadata->markUsedIn($traitUsageFile->getRealPath());
             }
         }
 
-        $traitUsagesToFiles = $usagesToFiles;
-
-        return new TraitSpottingResult($shortTraitNamesToLineCount, $traitUsagesToFiles);
+        return new TraitSpottingResult($traitsMetadatas);
     }
 
-    private function getRelativeFilePath(SplFileInfo $fileInfo): string
+    /**
+     * @param TraitMetadata[] $traitsMetadatas
+     */
+    private function matchTraitByShortName(array $traitsMetadatas, string $shortTraitName): ?TraitMetadata
     {
-        return substr($fileInfo->getRealPath(), strlen((string) getcwd()) + 1);
+        foreach ($traitsMetadatas as $traitMetadata) {
+            if ($traitMetadata->getShortTraitName() === $shortTraitName) {
+                return $traitMetadata;
+            }
+        }
+
+        return null;
     }
 }

src/Traits/TraitSpotter.php

@@ -0,0 +1,57 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Rector\SwissKnife\ValueObject\Traits;
+
+use Nette\Utils\FileSystem;
+
+final class TraitMetadata
+{
+    private int $lineCount;
+
+    /**
+     * @var string[]
+     */
+    private array $usedIn = [];
+
+    public function __construct(
+        private readonly string $filePath,
+        private string $shortTraitName
+    ) {
+        $this->lineCount = substr_count(FileSystem::read($filePath), PHP_EOL);
+    }
+
+    public function getShortTraitName(): string
+    {
+        return $this->shortTraitName;
+    }
+
+    public function getFilePath(): string
+    {
+        return $this->filePath;
+    }
+
+    public function markUsedIn(string $filePath): void
+    {
+        $this->usedIn[] = $filePath;
+    }
+
+    /**
+     * @return string[]
+     */
+    public function getUsedIn(): array
+    {
+        return $this->usedIn;
+    }
+
+    public function getUsedInCount(): int
+    {
+        return count($this->usedIn);
+    }
+
+    public function getLineCount(): int
+    {
+        return $this->lineCount;
+    }
+}