├── .editorconfig
├── .gitattributes
├── .gitignore
├── Makefile
├── README.md
├── app
    ├── Application
    │   └── UseCases
    │   │   ├── InspectHandler.php
    │   │   ├── InspectInput.php
    │   │   └── InspectOutput.php
    ├── Domain
    │   ├── Aggregators
    │   │   ├── FileAggregator.php
    │   │   └── WordAggregator.php
    │   ├── Entities
    │   │   ├── FileEntity.php
    │   │   └── WordEntity.php
    │   ├── Ports
    │   │   ├── AnalyzeService.php
    │   │   └── FileService.php
    │   └── ValueObjects
    │   │   └── Path.php
    ├── Infrastructure
    │   ├── Analyze
    │   │   ├── Adapters
    │   │   │   └── AnalyzeServiceAdapter.php
    │   │   ├── Mappers
    │   │   │   └── AnalyzeServiceMapper.php
    │   │   ├── Nodes
    │   │   │   ├── NodeExtractor.php
    │   │   │   └── NodeValidator.php
    │   │   └── Visitors
    │   │   │   └── ClassVisitor.php
    │   └── File
    │   │   ├── Adapters
    │   │       └── FileServiceAdapter.php
    │   │   └── Mappers
    │   │       └── FileFinderMapper.php
    ├── Presenter
    │   └── Commands
    │   │   ├── .gitkeep
    │   │   ├── InspectCommand.php
    │   │   ├── InspectCommandInput.php
    │   │   └── InspectCommandOutput.php
    └── Providers
    │   └── AppServiceProvider.php
├── bootstrap
    └── app.php
├── box.json
├── builds
    └── php-wording-detector
├── composer.json
├── composer.lock
├── config
    ├── app.php
    ├── commands.php
    └── view.php
├── php-wording-detector
├── phpunit.xml.dist
├── resources
    └── views
    │   └── inspect.blade.php
├── storage
    ├── app
    │   └── .gitignore
    └── framework
    │   └── views
    │       └── .gitignore
└── tests
    ├── Builders
        ├── FileAggregatorBuilder.php
        ├── builders.php
        └── stubs
        │   └── Foo.php
    ├── CreatesApplication.php
    ├── TestCase.php
    └── Unit
        ├── Application
            └── InspectHandlerTest.php
        ├── Domain
            ├── Aggregators
            │   └── WordAggregatorTest.php
            └── Entities
            │   └── WordEntityTest.php
        └── Infrastructure
            └── Nodes
                ├── NodeExtractorTest.php
                └── NodeValidatorTest.php


/.editorconfig:
--------------------------------------------------------------------------------
 1 | root = true
 2 | 
 3 | [*]
 4 | charset = utf-8
 5 | end_of_line = lf
 6 | insert_final_newline = true
 7 | indent_style = space
 8 | indent_size = 4
 9 | trim_trailing_whitespace = true
10 | 
11 | [*.md]
12 | trim_trailing_whitespace = false
13 | 
14 | [*.yml]
15 | indent_style = space
16 | indent_size = 2
17 | 


--------------------------------------------------------------------------------
/.gitattributes:
--------------------------------------------------------------------------------
1 | * text=auto eol=lf
2 | /.github export-ignore
3 | .scrutinizer.yml export-ignore
4 | BACKERS.md export-ignore
5 | CONTRIBUTING.md export-ignore
6 | CHANGELOG.md export-ignore
7 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | /vendor
2 | /.idea
3 | /.vscode
4 | /.vagrant
5 | .phpunit.result.cache
6 | 


--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
1 | test:
2 | 	vendor/bin/phpunit
3 | 
4 | cov:
5 | 	vendor/bin/phpunit --coverage-text | grep -A 4 "Summary:"


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | <p align="center">
 2 | <img src="https://github.com/DeGraciaMathieu/php-smelly-code-detector/blob/master/arts/robot.png" width="250">
 3 | </p>
 4 | 
 5 | [![testing](https://github.com/DeGraciaMathieu/php-wording-detector/actions/workflows/phpunit.yml/badge.svg)](https://github.com/DeGraciaMathieu/php-wording-detector/actions/workflows/phpunit.yml)
 6 | ![Packagist Version](https://img.shields.io/packagist/v/degraciamathieu/php-wording-detector)
 7 | ![Packagist PHP Version](https://img.shields.io/packagist/dependency-v/degraciamathieu/php-wording-detector/php)
 8 | 
 9 | # php-wording-detector
10 | 
11 | Simple tool to analyze and split the words contained in your code to check your DDD approach.
12 | 
13 | # Installation
14 | 
15 | ```
16 | Requires >= PHP 8.1
17 | ```
18 | 
19 | ## Phar
20 | This tool is distributed as a [PHP Archive (PHAR)](https://www.php.net/phar):
21 | 
22 | ```
23 | wget https://github.com/DeGraciaMathieu/php-wording-detector/raw/master/builds/php-wording-detector
24 | ```
25 | 
26 | ```
27 | php php-wording-detector --version
28 | ```
29 | 
30 | ## Composer
31 | Alternately, you can directly use composer :
32 | 
33 | ```
34 | composer require degraciamathieu/php-wording-detector --dev
35 | ```
36 | # Usage
37 | 
38 | By default only variables are analyzed :
39 | 
40 | ```
41 | php php-wording-detector inspect {path}
42 | ```
43 | 
44 | The `--with-method` option allows to parse the name of the methods :
45 | 
46 | ```
47 | php php-wording-detector inspect {path} --with-method
48 | ```
49 | 
50 | ```
51 | $ php php-wording-detector inspect app/Domains/Activity
52 | ❀ PHP Wording Detector ❀
53 | +-------------+-----------------------+-------------+
54 | | total words | total distincts words | average use |
55 | +-------------+-----------------------+-------------+
56 | | 2'166       | 52                    | 42          |
57 | +-------------+-----------------------+-------------+
58 | +--------------+-------+------------+
59 | | words        | usage | percentage |
60 | +--------------+-------+------------+
61 | | activity     | 667   | 31%        |
62 | | data         | 154   | 7%         |
63 | | code         | 150   | 7%         |
64 | | item         | 143   | 7%         |
65 | | query        | 128   | 6%         |
66 | | request      | 88    | 4%         |
67 | | mode         | 85    | 4%         |
68 | | translations | 78    | 4%         |
69 | | id           | 77    | 4%         |
70 | | type         | 63    | 3%         |
71 | | new          | 46    | 2%         |
72 | | product      | 41    | 2%         |
73 | | translation  | 41    | 2%         |
74 | | types        | 40    | 2%         |
75 | | master       | 33    | 2%         |
76 | | filters      | 29    | 1%         |
77 | | language     | 24    | 1%         |
78 | | builder      | 23    | 1%         |
79 | | items        | 22    | 1%         |
80 | | section      | 21    | under 1%   |
81 | +--------------+-------+------------+
82 | ```
83 | 


--------------------------------------------------------------------------------
/app/Application/UseCases/InspectHandler.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace App\Application\UseCases;
 4 | 
 5 | use Throwable;
 6 | use App\Domain\Ports\FileService;
 7 | use App\Domain\Ports\AnalyzeService;
 8 | use App\Application\UseCases\InspectInput;
 9 | use App\Application\UseCases\InspectOutput;
10 | 
11 | class InspectHandler
12 | {
13 |     public function __construct(
14 |         private FileService $fileService,
15 |         private AnalyzeService $analyzeService,
16 |     ) {
17 |     }
18 | 
19 |     public function handle(
20 |         InspectInput $input,
21 |         InspectOutput $output,
22 |     ): void {
23 | 
24 |         try {
25 | 
26 |             $output->hello();
27 | 
28 |             $fileAggregator = $this->fileService->all(
29 |                 path: $input->path(),
30 |             );
31 | 
32 |             $wordsAggregator = $this->analyzeService->getWords(
33 |                 fileAggregator: $fileAggregator,
34 |                 withMethod: $input->withMethod(),
35 |             );
36 | 
37 |             $output->present($wordsAggregator);
38 | 
39 |         } catch (Throwable $th) {
40 |             $output->error($th);
41 |         }
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/app/Application/UseCases/InspectInput.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace App\Application\UseCases;
 4 | 
 5 | use App\Domain\ValueObjects\Path;
 6 | 
 7 | interface InspectInput 
 8 | {
 9 |     public function path(): Path;
10 |     public function withMethod(): bool;
11 | }
12 | 


--------------------------------------------------------------------------------
/app/Application/UseCases/InspectOutput.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace App\Application\UseCases;
 4 | 
 5 | use Throwable;
 6 | use App\Domain\Aggregators\WordAggregator;
 7 | 
 8 | interface InspectOutput
 9 | {
10 |     public function hello();
11 |     public function present(WordAggregator $wordAggregator);
12 |     public function error(Throwable $th);
13 | }


--------------------------------------------------------------------------------
/app/Domain/Aggregators/FileAggregator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace App\Domain\Aggregators;
 4 | 
 5 | use App\Domain\Entities\FileEntity;
 6 | 
 7 | class FileAggregator
 8 | {
 9 |     private array $files = [];
10 | 
11 |     public function add(FileEntity $fileEntity): void
12 |     {
13 |         $this->files[] = $fileEntity;
14 |     }
15 | 
16 |     public function files(): array
17 |     {
18 |         return $this->files;
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/app/Domain/Aggregators/WordAggregator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace App\Domain\Aggregators;
 4 | 
 5 | use App\Domain\Entities\WordEntity;
 6 | use App\Domain\Services\WordSorter;
 7 | 
 8 | class WordAggregator
 9 | {
10 |     private array $words = [];
11 | 
12 |     public function add(WordEntity $wordEntity): void
13 |     {
14 |         if ($wordEntity->canBeIgnored()) {
15 |             return;
16 |         }
17 | 
18 |         $this->increment($wordEntity);
19 |     }
20 | 
21 |     public function sort(): void
22 |     {
23 |         uasort($this->words, function ($a, $b) {
24 |             return $this->sortWordsByDesc($a, $b);
25 |         });
26 |     }
27 | 
28 |     public function words(): array
29 |     {
30 |         return $this->words;
31 |     }
32 | 
33 |     private function increment(WordEntity $wordEntity): void
34 |     {
35 |         $word = $wordEntity->value();
36 | 
37 |         /**
38 |          * Wow, it works well, don't judge me
39 |          */
40 |         @$this->words[$word]++;
41 |     }
42 | 
43 |     private function sortWordsByDesc($a, $b): int
44 |     {
45 |         if ($a == $b) {
46 |             return 0;
47 |         }
48 | 
49 |         return ($a < $b) ? 1 : -1;
50 |     }
51 | }
52 | 


--------------------------------------------------------------------------------
/app/Domain/Entities/FileEntity.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace App\Domain\Entities;
 4 | 
 5 | use App\Domain\ValueObjects\Path;
 6 | 
 7 | class FileEntity
 8 | {
 9 |     public function __construct(
10 |         public Path $fullPath,
11 |         public Path $displayPath,
12 |         public string $contents,
13 |     ) {}
14 | 
15 |     public static function from(array $attributes): self
16 |     {
17 |         return new self(
18 |             fullPath: Path::from($attributes['fullPath']),
19 |             displayPath: Path::from($attributes['displayPath']),
20 |             contents: $attributes['contents'],
21 |         );
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/app/Domain/Entities/WordEntity.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace App\Domain\Entities;
 4 | 
 5 | class WordEntity
 6 | {
 7 |     public function __construct(
 8 |         private string $value,
 9 |     ) {}
10 | 
11 |     public static function from(string $word): self
12 |     {
13 |         $word = strtolower($word);
14 | 
15 |         return new self($word);
16 |     }
17 | 
18 |     public function canBeIgnored(): bool
19 |     {
20 |         return $this->value === 'this';
21 |     }
22 | 
23 |     public function value(): string
24 |     {
25 |         return $this->value;
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/app/Domain/Ports/AnalyzeService.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace App\Domain\Ports;
 4 | 
 5 | use App\Domain\Aggregators\FileAggregator;
 6 | use App\Domain\Aggregators\WordAggregator;
 7 | 
 8 | interface AnalyzeService
 9 | {
10 |      /**
11 |       * Retrieve all words from a set of files.
12 |       *
13 |       * withMethod argument allows including the words present in the function signatures.
14 |       */
15 |      public function getWords(FileAggregator $fileAggregator, bool $withMethod): WordAggregator;
16 | }
17 | 


--------------------------------------------------------------------------------
/app/Domain/Ports/FileService.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace App\Domain\Ports;
 4 | 
 5 | use App\Domain\Aggregators\FileAggregator;
 6 | use App\Domain\ValueObjects\Path;
 7 | 
 8 | interface FileService
 9 | {
10 |      /**
11 |       * Retrieves all files recursively in an absolute path.
12 |       */
13 |      public function all(Path $path): FileAggregator;
14 | }
15 | 


--------------------------------------------------------------------------------
/app/Domain/ValueObjects/Path.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace App\Domain\ValueObjects;
 4 | 
 5 | class Path
 6 | {
 7 |     public function __construct(
 8 |         private string $value,
 9 |     ) {}
10 | 
11 |     public static function from(string $value): self
12 |     {
13 |         static::guard($value);
14 | 
15 |         return new self($value);
16 |     }
17 | 
18 |     private static function guard(string $value): void
19 |     {
20 |         //
21 |     }
22 | 
23 |     public function value(): string
24 |     {
25 |         return $this->value;
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/app/Infrastructure/Analyze/Adapters/AnalyzeServiceAdapter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace App\Infrastructure\Analyze\Adapters;
 4 | 
 5 | use PhpParser\Parser;
 6 | use PhpParser\NodeTraverser;
 7 | use App\Domain\Entities\FileEntity;
 8 | use App\Domain\Ports\AnalyzeService;
 9 | use App\Domain\Aggregators\FileAggregator;
10 | use App\Domain\Aggregators\WordAggregator;
11 | use App\Infrastructure\Analyze\Visitors\ClassVisitor;
12 | use App\Infrastructure\Analyze\Mappers\AnalyzeServiceMapper;
13 | 
14 | class AnalyzeServiceAdapter implements AnalyzeService
15 | {
16 |     public function __construct(
17 |         private Parser $parser,
18 |         private AnalyzeServiceMapper $mapper,
19 |     ) {}
20 | 
21 |     public function getWords(FileAggregator $fileAggregator, bool $withMethod): WordAggregator
22 |     {
23 |         $files = $fileAggregator->files();
24 | 
25 |         foreach ($files as $file) {
26 |             $this->getFileWords($file, $withMethod);
27 |         }
28 | 
29 |         return $this->mapper->aggregate();
30 |     }
31 | 
32 |     private function getFileWords(FileEntity $file, bool $withMethod)
33 |     {
34 |         $traverser = new NodeTraverser();
35 | 
36 |         $visitor = $this->addVisitor($traverser, $withMethod);
37 | 
38 |         $this->traverseVisitor($traverser, $file);
39 | 
40 |         $this->mapper->map($visitor->words);
41 |     }
42 | 
43 |     private function addVisitor(NodeTraverser $traverser, bool $withMethod): ClassVisitor
44 |     {
45 |         $visitor = new ClassVisitor($withMethod);
46 | 
47 |         $traverser->addVisitor($visitor);
48 | 
49 |         return $visitor;
50 |     }
51 | 
52 |     private function traverseVisitor(NodeTraverser $traverser, $file): void
53 |     {
54 |         $contents = $file->contents;
55 | 
56 |         $nodes = $this->parser->parse($contents);
57 | 
58 |         $traverser->traverse($nodes);
59 |     }
60 | }
61 | 


--------------------------------------------------------------------------------
/app/Infrastructure/Analyze/Mappers/AnalyzeServiceMapper.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace App\Infrastructure\Analyze\Mappers;
 4 | 
 5 | use App\Domain\Entities\WordEntity;
 6 | use App\Domain\Aggregators\WordAggregator;
 7 | 
 8 | class AnalyzeServiceMapper
 9 | {
10 |     public function __construct(
11 |         private WordAggregator $wordAggregator,
12 |     ) {
13 |     }
14 | 
15 |     public function map(array $words): void
16 |     {
17 |         foreach ($words as $word) {
18 |             $this->add($word);
19 |         }
20 |     }
21 | 
22 |     public function aggregate(): WordAggregator
23 |     {
24 |         return $this->wordAggregator;
25 |     }
26 | 
27 |     private function add(string $word): void
28 |     {
29 |         $this->wordAggregator->add(
30 |             WordEntity::from($word),
31 |         );
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/app/Infrastructure/Analyze/Nodes/NodeExtractor.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace App\Infrastructure\Analyze\Nodes;
 4 | 
 5 | use PhpParser\Node;
 6 | use PhpParser\Node\Expr\Variable;
 7 | 
 8 | final class NodeExtractor
 9 | {
10 |     public static function cutNameIntoWords(Node $node): array
11 |     {
12 |         $name = self::getNodeName($node);
13 | 
14 |         preg_match_all("/([a-z]+)|([A-Z][a-z]+)|([^_\W]+)/", $name, $matches);
15 | 
16 |         return $matches[0];
17 |     }
18 | 
19 |     public static function getNodeName(Node $node): string
20 |     {
21 |         $name = $node->name;
22 | 
23 |         if ($name instanceof Variable) {
24 |             return $name->name;
25 |         }
26 | 
27 |         return $name;
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/app/Infrastructure/Analyze/Nodes/NodeValidator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace App\Infrastructure\Analyze\Nodes;
 4 | 
 5 | use PhpParser\Node;
 6 | use PhpParser\Node\Expr\Variable;
 7 | use PhpParser\Node\Stmt\ClassMethod;
 8 | 
 9 | final class NodeValidator
10 | {
11 |     public static function isAVariable(Node $node): bool
12 |     {
13 |         return $node instanceof Variable;
14 |     }
15 | 
16 |     public static function isAMethod(Node $node): bool
17 |     {
18 |         return $node instanceof ClassMethod;
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/app/Infrastructure/Analyze/Visitors/ClassVisitor.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace App\Infrastructure\Analyze\Visitors;
 4 | 
 5 | use PhpParser\Node;
 6 | use PhpParser\NodeVisitorAbstract;
 7 | use App\Infrastructure\Analyze\Nodes\NodeExtractor;
 8 | use App\Infrastructure\Analyze\Nodes\NodeValidator;
 9 | 
10 | final class ClassVisitor extends NodeVisitorAbstract
11 | {
12 | 	public array $words = [];
13 | 
14 |     public function __construct(
15 |         private bool $withMethod,
16 |     ) {}
17 | 
18 |     public function leaveNode(Node $node): void
19 |     {
20 |         if ($this->mustParseThisNode($node)) {
21 | 
22 |             $words = NodeExtractor::cutNameIntoWords($node);
23 | 
24 |             $this->words = array_merge($this->words, $words);
25 |         }
26 |     }
27 | 
28 |     private function mustParseThisNode(Node $node): bool
29 |     {
30 |         if (NodeValidator::isAVariable($node)) {
31 |             return true;
32 |         }
33 | 
34 |         return $this->withMethod 
35 |             ? NodeValidator::isAMethod($node) 
36 |             : false;
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/app/Infrastructure/File/Adapters/FileServiceAdapter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace App\Infrastructure\File\Adapters;
 4 | 
 5 | use App\Domain\ValueObjects\Path;
 6 | use App\Domain\Ports\FileService;
 7 | use App\Domain\Aggregators\FileAggregator;
 8 | use DeGraciaMathieu\FileExplorer\FileFinder;
 9 | use App\Infrastructure\File\Mappers\FileFinderMapper;
10 | 
11 | class FileServiceAdapter implements FileService
12 | {
13 |     public function __construct(
14 |         private FileFinderMapper $mapper,
15 |     ) {}
16 | 
17 |     public function all(Path $path): FileAggregator
18 |     {
19 |         $finder = new FileFinder(
20 |             basePath: getcwd(),
21 |         );
22 | 
23 |         $files = $finder->getFiles(
24 |             $path->value(),
25 |         );
26 | 
27 |         return $this->mapper->map($files);
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/app/Infrastructure/File/Mappers/FileFinderMapper.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace App\Infrastructure\File\Mappers;
 4 | 
 5 | use App\Domain\Entities\FileEntity;
 6 | use DeGraciaMathieu\FileExplorer\File;
 7 | use App\Domain\Aggregators\FileAggregator;
 8 | 
 9 | class FileFinderMapper
10 | {
11 |     public function __construct(
12 |         private FileAggregator $fileAggregator,
13 |     ) {
14 |     }
15 | 
16 |     public function map($files): FileAggregator
17 |     {
18 |         foreach ($files as $file) {
19 | 
20 |             $fileEntity = $this->makeEntity($file);
21 | 
22 |             $this->fileAggregator->add($fileEntity);
23 |         }
24 | 
25 |         return $this->fileAggregator;
26 |     }
27 | 
28 |     private function makeEntity(File $file): FileEntity
29 |     {
30 |         return FileEntity::from([
31 |             'fullPath' => $file->fullPath,
32 |             'displayPath' => $file->displayPath,
33 |             'contents' => $file->contents(),
34 |         ]);
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/app/Presenter/Commands/.gitkeep:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/DeGraciaMathieu/php-wording-detector/4a5b25ebeae0287beb8725b2264bdfca7e6211eb/app/Presenter/Commands/.gitkeep


--------------------------------------------------------------------------------
/app/Presenter/Commands/InspectCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace App\Presenter\Commands;
 4 | 
 5 | use Termwind\HtmlRenderer;
 6 | use Illuminate\View\Factory as ViewFactory;
 7 | use LaravelZero\Framework\Commands\Command;
 8 | use App\Application\UseCases\InspectHandler;
 9 | 
10 | class InspectCommand extends Command
11 | {
12 |     /**
13 |      * The signature of the command.
14 |      *
15 |      * @var string
16 |      */
17 |     protected $signature = 'inspect {path} {--with-method}';
18 | 
19 |     /**
20 |      * The description of the command.
21 |      *
22 |      * @var string
23 |      */
24 |     protected $description = 'summary analysis';
25 | 
26 |     /**
27 |      * Execute the console command.
28 |      *
29 |      * @return mixed
30 |      */
31 |     public function handle(
32 |         InspectHandler $inspectHandler,
33 |         InspectCommandOutput $inspectCommandOutput,
34 |     ) {
35 |         $inspectHandler->handle(
36 |             new InspectCommandInput(
37 |                 path: $this->argument('path'),
38 |                 withMethod: $this->option('with-method'),
39 |             ),
40 |             $inspectCommandOutput
41 |         );
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/app/Presenter/Commands/InspectCommandInput.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace App\Presenter\Commands;
 4 | 
 5 | use App\Application\UseCases\InspectInput;
 6 | use App\Domain\ValueObjects\Path;
 7 | 
 8 | class InspectCommandInput implements InspectInput
 9 | {
10 |     public function __construct(
11 |         private string $path,
12 |         private bool $withMethod,
13 |     ){}
14 | 
15 |     public function path(): Path
16 |     {
17 |         return Path::from($this->path);
18 |     }
19 | 
20 |     public function withMethod(): bool
21 |     {
22 |         return $this->withMethod;
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/app/Presenter/Commands/InspectCommandOutput.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace App\Presenter\Commands;
 4 | 
 5 | use Throwable;
 6 | use Termwind\HtmlRenderer;
 7 | use function Laravel\Prompts\note;
 8 | use function Laravel\Prompts\error;
 9 | use App\Domain\Aggregators\WordAggregator;
10 | use Illuminate\View\Factory as ViewFactory;
11 | use App\Application\UseCases\InspectOutput;
12 | use Illuminate\Contracts\View\View as ViewContract;
13 | use Symfony\Component\Console\Output\OutputInterface;
14 | 
15 | class InspectCommandOutput implements InspectOutput
16 | {
17 |     public function __construct(
18 |         private ViewFactory $view,
19 |         private HtmlRenderer $htmlRenderer,
20 |     ) {
21 |     }
22 | 
23 |     public function hello(): void
24 |     {
25 |         note('❀ PHP Wording Detector ❀');
26 |     }
27 | 
28 |     public function present(WordAggregator $wordAggregator): void
29 |     {
30 |         $wordAggregator->sort();
31 | 
32 |         $html = $this->makeHtml($wordAggregator);
33 | 
34 |         $this->renderHtml($html);
35 |     }
36 | 
37 |     public function error(Throwable $th): void
38 |     {
39 |         error($th);
40 |     }
41 | 
42 |     private function makeHtml(WordAggregator $wordAggregator): ViewContract
43 |     {
44 |         $words = $wordAggregator->words();
45 | 
46 |         return $this->view->make('inspect', [
47 |             'words' => $words,
48 |         ]);
49 |     }
50 | 
51 |     private function renderHtml(ViewContract $html): void
52 |     {
53 |         $this->htmlRenderer->render($html, OutputInterface::OUTPUT_NORMAL);
54 |     }
55 | }
56 | 


--------------------------------------------------------------------------------
/app/Providers/AppServiceProvider.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace App\Providers;
 4 | 
 5 | use PhpParser\Parser;
 6 | use PhpParser\ParserFactory;
 7 | use App\Domain\Ports\FileService;
 8 | use Illuminate\Support\ServiceProvider;
 9 | use App\Domain\Ports\AnalyzeService;
10 | use App\Infrastructure\File\Adapters\FileServiceAdapter;
11 | use App\Infrastructure\Analyze\Adapters\AnalyzeServiceAdapter;
12 | 
13 | class AppServiceProvider extends ServiceProvider
14 | {
15 |     /**
16 |      * Bootstrap any application services.
17 |      */
18 |     public function boot(): void
19 |     {
20 |         //
21 |     }
22 | 
23 |     /**
24 |      * Register any application services.
25 |      */
26 |     public function register(): void
27 |     {
28 |         $this->app->singleton(Parser::class, function ($app) {
29 | 
30 |             $parserFactory = new ParserFactory();
31 | 
32 |             return $parserFactory->create(ParserFactory::PREFER_PHP7);
33 |         });
34 | 
35 |         $this->app->bind(FileService::class, FileServiceAdapter::class);
36 |         $this->app->bind(AnalyzeService::class, AnalyzeServiceAdapter::class);
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/bootstrap/app.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*
 4 | |--------------------------------------------------------------------------
 5 | | Create The Application
 6 | |--------------------------------------------------------------------------
 7 | |
 8 | | The first thing we will do is create a new Laravel application instance
 9 | | which serves as the "glue" for all the components of Laravel, and is
10 | | the IoC container for the system binding all of the various parts.
11 | |
12 | */
13 | 
14 | $app = new LaravelZero\Framework\Application(
15 |     dirname(__DIR__)
16 | );
17 | 
18 | /*
19 | |--------------------------------------------------------------------------
20 | | Bind Important Interfaces
21 | |--------------------------------------------------------------------------
22 | |
23 | | Next, we need to bind some important interfaces into the container so
24 | | we will be able to resolve them when needed. The kernels serve the
25 | | incoming requests to this application from both the web and CLI.
26 | |
27 | */
28 | 
29 | $app->singleton(
30 |     Illuminate\Contracts\Console\Kernel::class,
31 |     LaravelZero\Framework\Kernel::class
32 | );
33 | 
34 | $app->singleton(
35 |     Illuminate\Contracts\Debug\ExceptionHandler::class,
36 |     Illuminate\Foundation\Exceptions\Handler::class
37 | );
38 | 
39 | /*
40 | |--------------------------------------------------------------------------
41 | | Return The Application
42 | |--------------------------------------------------------------------------
43 | |
44 | | This script returns the application instance. The instance is given to
45 | | the calling script so we can separate the building of the instances
46 | | from the actual running of the application and sending responses.
47 | |
48 | */
49 | 
50 | return $app;
51 | 


--------------------------------------------------------------------------------
/box.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "chmod": "0755",
 3 |     "directories": [
 4 |         "app",
 5 |         "bootstrap",
 6 |         "config",
 7 |         "vendor",
 8 |         "resources"
 9 |     ],
10 |     "files": [
11 |         "composer.json"
12 |     ],
13 |     "exclude-composer-files": false,
14 |     "compression": "GZ",
15 |     "compactors": [
16 |         "KevinGH\\Box\\Compactor\\Php",
17 |         "KevinGH\\Box\\Compactor\\Json"
18 |     ]
19 | }
20 | 


--------------------------------------------------------------------------------
/builds/php-wording-detector:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/DeGraciaMathieu/php-wording-detector/4a5b25ebeae0287beb8725b2264bdfca7e6211eb/builds/php-wording-detector


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "degraciamathieu/php-wording-detector",
 3 |     "description": "check your DDD approach by analyzing your variables",
 4 |     "keywords": ["php", "quality", "ci", "metrics", "static-analyzer", "ddd"],
 5 |     "type": "package",
 6 |     "license": "MIT",
 7 |     "support": {
 8 |         "issues": "https://github.com/DeGraciaMathieu/php-wording-detector/issues",
 9 |         "source": "https://github.com/DeGraciaMathieu/php-wording-detector"
10 |     },
11 |     "authors": [
12 |         {
13 |             "name": "De Gracia Mathieu",
14 |             "email": "dev@degracia-mathieu.fr"
15 |         }
16 |     ],
17 |     "require": {
18 |         "php": "^8.1",
19 |         "degraciamathieu/php-file-explorer": "0.4.*",
20 |         "illuminate/view": "^10.0",
21 |         "laravel-zero/framework": "^10.0",
22 |         "laravel/prompts": "^0.1.21",
23 |         "nikic/php-parser": "^4.13",
24 |         "nunomaduro/termwind": "^1.15"
25 |     },
26 |     "require-dev": {
27 |         "laravel/pint": "^1.5",
28 |         "mockery/mockery": "^1.5.1",
29 |         "phpunit/phpunit": "^10.0"
30 |     },
31 |     "autoload": {
32 |         "psr-4": {
33 |             "App\\": "app/",
34 |             "Database\\Factories\\": "database/factories/",
35 |             "Database\\Seeders\\": "database/seeders/"
36 |         }
37 |     },
38 |     "autoload-dev": {
39 |         "files": [
40 |             "./tests/Builders/builders.php"
41 |         ],
42 |         "psr-4": {
43 |             "Tests\\": "tests/"
44 |         }
45 |     },
46 |     "config": {
47 |         "preferred-install": "dist",
48 |         "sort-packages": true,
49 |         "optimize-autoloader": true,
50 |         "allow-plugins": {
51 |             "pestphp/pest-plugin": true
52 |         }
53 |     },
54 |     "minimum-stability": "stable",
55 |     "prefer-stable": true,
56 |     "bin": ["php-wording-detector"]
57 | }
58 | 


--------------------------------------------------------------------------------
/config/app.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | return [
 4 | 
 5 |     /*
 6 |     |--------------------------------------------------------------------------
 7 |     | Application Name
 8 |     |--------------------------------------------------------------------------
 9 |     |
10 |     | This value is the name of your application. This value is used when the
11 |     | framework needs to place the application's name in a notification or
12 |     | any other location as required by the application or its packages.
13 |     |
14 |     */
15 | 
16 |     'name' => 'Php-wording-detector',
17 | 
18 |     /*
19 |     |--------------------------------------------------------------------------
20 |     | Application Version
21 |     |--------------------------------------------------------------------------
22 |     |
23 |     | This value determines the "version" your application is currently running
24 |     | in. You may want to follow the "Semantic Versioning" - Given a version
25 |     | number MAJOR.MINOR.PATCH when an update happens: https://semver.org.
26 |     |
27 |     */
28 | 
29 |     'version' => app('git.version'),
30 | 
31 |     /*
32 |     |--------------------------------------------------------------------------
33 |     | Application Environment
34 |     |--------------------------------------------------------------------------
35 |     |
36 |     | This value determines the "environment" your application is currently
37 |     | running in. This may determine how you prefer to configure various
38 |     | services the application utilizes. This can be overridden using
39 |     | the global command line "--env" option when calling commands.
40 |     |
41 |     */
42 | 
43 |     'env' => 'development',
44 | 
45 |     /*
46 |     |--------------------------------------------------------------------------
47 |     | Application Timezone
48 |     |--------------------------------------------------------------------------
49 |     |
50 |     | Here you may specify the default timezone for your application, which
51 |     | will be used by the PHP date and date-time functions. We have gone
52 |     | ahead and set this to a sensible default for you out of the box.
53 |     |
54 |     */
55 | 
56 |     'timezone' => 'UTC',
57 | 
58 |     /*
59 |     |--------------------------------------------------------------------------
60 |     | Autoloaded Service Providers
61 |     |--------------------------------------------------------------------------
62 |     |
63 |     | The service providers listed here will be automatically loaded on the
64 |     | request to your application. Feel free to add your own services to
65 |     | this array to grant expanded functionality to your applications.
66 |     |
67 |     */
68 | 
69 |     'providers' => [
70 |         App\Providers\AppServiceProvider::class,
71 |     ],
72 | 
73 | ];
74 | 


--------------------------------------------------------------------------------
/config/commands.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | return [
 4 | 
 5 |     /*
 6 |     |--------------------------------------------------------------------------
 7 |     | Default Command
 8 |     |--------------------------------------------------------------------------
 9 |     |
10 |     | Laravel Zero will always run the command specified below when no command name is
11 |     | provided. Consider update the default command for single command applications.
12 |     | You cannot pass arguments to the default command because they are ignored.
13 |     |
14 |     */
15 | 
16 |     'default' => NunoMaduro\LaravelConsoleSummary\SummaryCommand::class,
17 | 
18 |     /*
19 |     |--------------------------------------------------------------------------
20 |     | Commands Paths
21 |     |--------------------------------------------------------------------------
22 |     |
23 |     | This value determines the "paths" that should be loaded by the console's
24 |     | kernel. Foreach "path" present on the array provided below the kernel
25 |     | will extract all "Illuminate\Console\Command" based class commands.
26 |     |
27 |     */
28 | 
29 |     'paths' => [app_path('Presenter/Commands')],
30 | 
31 |     /*
32 |     |--------------------------------------------------------------------------
33 |     | Added Commands
34 |     |--------------------------------------------------------------------------
35 |     |
36 |     | You may want to include a single command class without having to load an
37 |     | entire folder. Here you can specify which commands should be added to
38 |     | your list of commands. The console's kernel will try to load them.
39 |     |
40 |     */
41 | 
42 |     'add' => [
43 |         // ..
44 |     ],
45 | 
46 |     /*
47 |     |--------------------------------------------------------------------------
48 |     | Hidden Commands
49 |     |--------------------------------------------------------------------------
50 |     |
51 |     | Your application commands will always be visible on the application list
52 |     | of commands. But you can still make them "hidden" specifying an array
53 |     | of commands below. All "hidden" commands can still be run/executed.
54 |     |
55 |     */
56 | 
57 |     'hidden' => [
58 |         NunoMaduro\LaravelConsoleSummary\SummaryCommand::class,
59 |         Symfony\Component\Console\Command\DumpCompletionCommand::class,
60 |         Symfony\Component\Console\Command\HelpCommand::class,
61 |         Illuminate\Console\Scheduling\ScheduleRunCommand::class,
62 |         Illuminate\Console\Scheduling\ScheduleListCommand::class,
63 |         Illuminate\Console\Scheduling\ScheduleFinishCommand::class,
64 |         Illuminate\Foundation\Console\VendorPublishCommand::class,
65 |         LaravelZero\Framework\Commands\StubPublishCommand::class,
66 |     ],
67 | 
68 |     /*
69 |     |--------------------------------------------------------------------------
70 |     | Removed Commands
71 |     |--------------------------------------------------------------------------
72 |     |
73 |     | Do you have a service provider that loads a list of commands that
74 |     | you don't need? No problem. Laravel Zero allows you to specify
75 |     | below a list of commands that you don't to see in your app.
76 |     |
77 |     */
78 | 
79 |     'remove' => [
80 |         // ..
81 |     ],
82 | 
83 | ];
84 | 


--------------------------------------------------------------------------------
/config/view.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | return [
 4 |     'paths' => [
 5 |         resource_path('views'),
 6 |     ],
 7 |     'compiled' => \Phar::running()
 8 |         ? getcwd()
 9 |         : env('VIEW_COMPILED_PATH', realpath(storage_path('framework/views'))),
10 | ];
11 | 


--------------------------------------------------------------------------------
/php-wording-detector:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env php
 2 | <?php
 3 | 
 4 | define('LARAVEL_START', microtime(true));
 5 | 
 6 | /*
 7 | |--------------------------------------------------------------------------
 8 | | Register The Auto Loader
 9 | |--------------------------------------------------------------------------
10 | |
11 | | Composer provides a convenient, automatically generated class loader
12 | | for our application. We just need to utilize it! We'll require it
13 | | into the script here so that we do not have to worry about the
14 | | loading of any our classes "manually". Feels great to relax.
15 | |
16 | */
17 | 
18 | $autoloader = require file_exists(__DIR__.'/vendor/autoload.php') ?  __DIR__.'/vendor/autoload.php' : __DIR__.'/../../autoload.php';
19 | 
20 | $app = require_once __DIR__.'/bootstrap/app.php';
21 | 
22 | /*
23 | |--------------------------------------------------------------------------
24 | | Run The Artisan Application
25 | |--------------------------------------------------------------------------
26 | |
27 | | When we run the console application, the current CLI command will be
28 | | executed in this console and the response sent back to a terminal
29 | | or another output device for the developers. Here goes nothing!
30 | |
31 | */
32 | 
33 | $kernel = $app->make(Illuminate\Contracts\Console\Kernel::class);
34 | 
35 | $status = $kernel->handle(
36 |     $input = new Symfony\Component\Console\Input\ArgvInput,
37 |     new Symfony\Component\Console\Output\ConsoleOutput
38 | );
39 | 
40 | /*
41 | |--------------------------------------------------------------------------
42 | | Shutdown The Application
43 | |--------------------------------------------------------------------------
44 | |
45 | | Once Artisan has finished running, we will fire off the shutdown events
46 | | so that any final work may be done by the application before we shut
47 | | down the process. This is the last thing to happen to the request.
48 | |
49 | */
50 | 
51 | $kernel->terminate($input, $status);
52 | 
53 | exit($status);
54 | 


--------------------------------------------------------------------------------
/phpunit.xml.dist:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" backupGlobals="false" bootstrap="vendor/autoload.php" colors="true" processIsolation="false" stopOnFailure="false" xsi:noNamespaceSchemaLocation="https://schema.phpunit.de/10.2/phpunit.xsd" cacheDirectory=".phpunit.cache" backupStaticProperties="false">
 3 |   <testsuites>
 4 |     <testsuite name="Unit">
 5 |       <directory suffix="Test.php">./tests/Unit</directory>
 6 |     </testsuite>
 7 |   </testsuites>
 8 |   <coverage/>
 9 |   <source>
10 |     <include>
11 |       <directory suffix=".php">./app</directory>
12 |     </include>
13 |   </source>
14 | </phpunit>
15 | 


--------------------------------------------------------------------------------
/resources/views/inspect.blade.php:
--------------------------------------------------------------------------------
 1 | <div>
 2 |     @if($words)
 3 |     <table>
 4 |         <thead>
 5 |         <tr>
 6 |             <th>total words</th>
 7 |             <th>total distincts words</th>
 8 |             <th>average use</th>
 9 |         </tr>
10 |         </thead>
11 |         <tr>
12 |             <td>{{ number_format(array_sum($words), 0, ".", "'") }}</td>
13 |             <td>{{ count($words) }}</td>
14 |             <td>{{ number_format(array_sum($words) / count($words)) }}</td>
15 |         </tr>
16 |     </table>
17 |     <table>
18 |         <thead>
19 |         <tr>
20 |             <th>words</th>
21 |             <th>usage</th>
22 |             <th>percentage</th>
23 |         </tr>
24 |         </thead>
25 |         @foreach(array_slice($words, 0, 20) as $name => $usage)
26 |         <tr>
27 |             <td>{{ $name }}</td>
28 |             <td>{{ $usage }}</td>
29 |             <td>
30 |                 @php
31 |                     $percentage = $usage * 100 / array_sum($words);
32 |                 @endphp
33 |                 @if($percentage < 1)
34 |                     under 1%
35 |                 @else
36 |                     {{ number_format($percentage) }}%
37 |                 @endif
38 |             </td>
39 |         </tr>
40 |         @endforeach
41 |     </table>
42 |     @else
43 |         No files found.
44 |     @endif
45 | </div>
46 | 


--------------------------------------------------------------------------------
/storage/app/.gitignore:
--------------------------------------------------------------------------------
1 | *
2 | !.gitignore


--------------------------------------------------------------------------------
/storage/framework/views/.gitignore:
--------------------------------------------------------------------------------
1 | *
2 | !.gitignore


--------------------------------------------------------------------------------
/tests/Builders/FileAggregatorBuilder.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Tests\Builders;
 4 | 
 5 | use App\Domain\Entities\FileEntity;
 6 | use App\Domain\Aggregators\FileAggregator;
 7 | 
 8 | class FileAggregatorBuilder
 9 | {
10 |     private FileAggregator $fileAggregator;
11 | 
12 |     public function __construct() 
13 |     {
14 |         $this->fileAggregator = new FileAggregator();
15 |     }
16 | 
17 |     public function withFile(): FileAggregatorBuilder
18 |     {
19 |         $this->fileAggregator->add($this->makeFileEntity());
20 | 
21 |         return $this;
22 |     }
23 | 
24 |     public function build(): FileAggregator
25 |     {
26 |         return $this->fileAggregator;
27 |     }
28 | 
29 |     private function makeFileEntity(): FileEntity
30 |     {
31 |         return FileEntity::from([
32 |             'fullPath' => '.',
33 |             'displayPath' => '.',
34 |             'contents' => file_get_contents(__DIR__ . '/stubs/Foo.php'),
35 |         ]);
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/tests/Builders/builders.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | use Tests\Builders\FileAggregatorBuilder;
4 | function fileAggregator() {
5 |     return new FileAggregatorBuilder();
6 | }
7 | 


--------------------------------------------------------------------------------
/tests/Builders/stubs/Foo.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | class Foo
4 | {
5 |     public function bar()
6 |     {
7 |         $var = 1;
8 |     }
9 | }


--------------------------------------------------------------------------------
/tests/CreatesApplication.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Tests;
 4 | 
 5 | use Illuminate\Contracts\Console\Kernel;
 6 | use Illuminate\Foundation\Application;
 7 | 
 8 | trait CreatesApplication
 9 | {
10 |     /**
11 |      * Creates the application.
12 |      */
13 |     public function createApplication(): Application
14 |     {
15 |         $app = require __DIR__.'/../bootstrap/app.php';
16 | 
17 |         $app->make(Kernel::class)->bootstrap();
18 | 
19 |         return $app;
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/tests/TestCase.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Tests;
 4 | 
 5 | use LaravelZero\Framework\Testing\TestCase as BaseTestCase;
 6 | 
 7 | abstract class TestCase extends BaseTestCase
 8 | {
 9 |     use CreatesApplication;
10 | }
11 | 


--------------------------------------------------------------------------------
/tests/Unit/Application/InspectHandlerTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Tests\Unit\Application;
 4 | 
 5 | use Mockery;
 6 | use App\Domain\Ports\FileService;
 7 | use App\Domain\ValueObjects\Path;
 8 | use App\Domain\Ports\AnalyzeService;
 9 | use PHPUnit\Framework\Attributes\Test;
10 | use App\Application\UseCases\InspectInput;
11 | use App\Domain\Aggregators\FileAggregator;
12 | use App\Domain\Aggregators\WordAggregator;
13 | use App\Application\UseCases\InspectOutput;
14 | use App\Application\UseCases\InspectHandler;
15 | use Mockery\Adapter\Phpunit\MockeryTestCase;
16 | 
17 | class InspectHandlerTest extends MockeryTestCase
18 | {
19 |     #[Test]
20 |     public function it_can_find_the_number_of_words_in_files(): void
21 |     {
22 |         $handler = new InspectHandler(
23 |             $this->mockFileService(),
24 |             $this->mockAnalyzeService(),
25 |         );
26 | 
27 |         $handler->handle(
28 |             $this->mockInputInterface(),
29 |             $this->mockOutputInterface(),
30 |         );
31 |     }
32 | 
33 |     private function mockFileService(): FileService
34 |     {
35 |         $fileService = Mockery::mock(FileService::class);
36 | 
37 |         $fileService->expects('all')->andReturn($this->makeFileAggregator());
38 | 
39 |         return $fileService;
40 |     }
41 | 
42 |     private function makeFileAggregator(): FileAggregator
43 |     {
44 |         return fileAggregator()->withFile()->build();
45 |     }
46 | 
47 |     private function mockAnalyzeService(): AnalyzeService
48 |     {
49 |         return Mockery::mock(AnalyzeService::class)->shouldIgnoreMissing();
50 |     }
51 | 
52 |     private function mockInputInterface(): InspectInput
53 |     {
54 |         $input = Mockery::mock(InspectInput::class);
55 | 
56 |         $input->expects('path')->andReturn(Path::from('.'));
57 |         $input->expects('withMethod')->andReturn(false);
58 | 
59 |         return $input;
60 |     }
61 | 
62 |     private function mockOutputInterface(): InspectOutput
63 |     {
64 |         $output = Mockery::mock(InspectOutput::class)->shouldIgnoreMissing();
65 | 
66 |         $output->expects('error')
67 |             ->never()
68 |             ->withAnyArgs()
69 |             ->andReturnUsing(function ($th) {
70 |                 $this->fail('Unexpected call to error with exception: ' . $th->getMessage());
71 |             });
72 | 
73 |         $output->expects('present')
74 |             ->withArgs(function ($argument) {
75 |                 return $argument instanceof WordAggregator;
76 |             });
77 | 
78 |         return $output;
79 |     }
80 | }
81 | 


--------------------------------------------------------------------------------
/tests/Unit/Domain/Aggregators/WordAggregatorTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Tests\Unit\Domain\Aggregators;
 4 | 
 5 | use PHPUnit\Framework\TestCase;
 6 | use App\Domain\Entities\WordEntity;
 7 | use PHPUnit\Framework\Attributes\Test;
 8 | use App\Domain\Aggregators\WordAggregator;
 9 | 
10 | class WordAggregatorTest extends TestCase
11 | {
12 |     #[Test]
13 |     public function it_can_aggregate_words(): void
14 |     {
15 |         $aggregator = new WordAggregator();
16 | 
17 |         $aggregator->add(WordEntity::from('a'));
18 |         $aggregator->add(WordEntity::from('b'));
19 |         $aggregator->add(WordEntity::from('b'));
20 | 
21 |         $this->assertEquals([
22 |             'a' => 1,
23 |             'b' => 2,
24 |         ], $aggregator->words());
25 |     }
26 | 
27 |     #[Test]
28 |     public function it_can_sort_words(): void
29 |     {
30 |         $aggregator = new WordAggregator();
31 | 
32 |         $aggregator->add(WordEntity::from('a'));
33 |         $aggregator->add(WordEntity::from('b'));
34 |         $aggregator->add(WordEntity::from('b'));
35 | 
36 |         $aggregator->sort();
37 | 
38 |         $this->assertEquals([
39 |             'b' => 2,
40 |             'a' => 1,
41 |         ], $aggregator->words());
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/tests/Unit/Domain/Entities/WordEntityTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Tests\Unit\Domain\Aggregators;
 4 | 
 5 | use PHPUnit\Framework\TestCase;
 6 | use App\Domain\Entities\WordEntity;
 7 | use PHPUnit\Framework\Attributes\Test;
 8 | use PHPUnit\Framework\Attributes\DataProvider;
 9 | 
10 | class WordEntityTest extends TestCase
11 | {
12 |     #[Test]
13 |     public function it_lowercases_the_word_value(): void
14 |     {
15 |         $word = WordEntity::from('Foo');
16 | 
17 |         $this->assertSame($word->value(), 'foo');
18 |     }
19 | 
20 |     #[Test]
21 |     public function it_accepts_common_words(): void
22 |     {
23 |         $word = WordEntity::from('Foo');
24 | 
25 |         $this->assertFalse($word->canBeIgnored());
26 |     }
27 | 
28 | 
29 |     #[Test]
30 |     #[DataProvider('words')]
31 |     public function it_can_ignore_some_words(string $word): void
32 |     {
33 |         $word = WordEntity::from($word);
34 | 
35 |         $this->assertTrue($word->canBeIgnored());
36 |     }
37 | 
38 |     public static function words(): array
39 |     {
40 |         return [
41 |             ['this'],
42 |         ];
43 |     }
44 | }
45 | 


--------------------------------------------------------------------------------
/tests/Unit/Infrastructure/Nodes/NodeExtractorTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Tests\Unit\Infrastructure\Nodes;
 4 | 
 5 | use PHPUnit\Framework\TestCase;
 6 | use PhpParser\Node\Expr\Variable;
 7 | use PhpParser\Node\Stmt\ClassMethod;
 8 | use App\Infrastructure\Analyze\Nodes\NodeExtractor;
 9 | 
10 | class NodeExtractorTest extends TestCase
11 | {
12 |     /**
13 |      * @test
14 |      * @dataProvider nameProvider
15 |      */
16 |     public function it_can_cut_variable_into_words(string $name, array $expectedWords): void
17 |     {
18 |         $variable = new Variable(
19 |             name: $name,
20 |             attributes: [],
21 |         );
22 | 
23 |         $words = NodeExtractor::cutNameIntoWords($variable);
24 | 
25 |         $this->assertEquals($expectedWords, $words);
26 |     }
27 | 
28 |     /**
29 |      * @test
30 |      * @dataProvider nameProvider
31 |      */
32 |     public function it_can_cut_method_into_words(string $name, array $expectedWords): void
33 |     {
34 |         $method = new ClassMethod(
35 |             name: $name,
36 |         );
37 | 
38 |         $words = NodeExtractor::cutNameIntoWords($method);
39 | 
40 |         $this->assertEquals($expectedWords, $words);
41 |     }
42 | 
43 |     public static function nameProvider(): array
44 |     {
45 |         return [
46 |             ['getAllFoo', ['get', 'All', 'Foo']],
47 |             ['get_all_foo', ['get', 'all', 'foo']],
48 |             ['Get_All_Foo', ['Get', 'All', 'Foo']],
49 |             ['get_All_Foo', ['get', 'All', 'Foo']],
50 |             ['getallfoo', ['getallfoo']],
51 |             ['get', ['get']],
52 |         ];
53 |     }
54 | 
55 |     /**
56 |      * @test
57 |      */
58 |     public function it_can_get_the_name_even_if_its_a_variable(): void
59 |     {
60 |         $variable = new Variable(
61 |             name: new Variable(
62 |                 name: 'getAllFoo',
63 |             ),
64 |         );
65 | 
66 |         $words = NodeExtractor::cutNameIntoWords($variable);
67 | 
68 |         $this->assertEquals(['get', 'All', 'Foo'], $words);
69 |     }
70 | }
71 | 


--------------------------------------------------------------------------------
/tests/Unit/Infrastructure/Nodes/NodeValidatorTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Tests\Unit\Infrastructure\Nodes;
 4 | 
 5 | use PhpParser\Node\Expr\Array_;
 6 | use PHPUnit\Framework\TestCase;
 7 | use PhpParser\Node\Expr\Variable;
 8 | use PhpParser\Node\Stmt\ClassMethod;
 9 | use App\Infrastructure\Analyze\Nodes\NodeValidator;
10 | 
11 | class NodeValidatorTest extends TestCase
12 | {
13 |     /**
14 |      * @test
15 |      */
16 |     public function it_able_to_check_node_is_a_variable(): void
17 |     {
18 |         $variable = new Variable(
19 |             name: 'getAllFoo',
20 |             attributes: [],
21 |         );
22 | 
23 |         $isAVariable = NodeValidator::isAVariable($variable);
24 | 
25 |         $this->assertTrue($isAVariable);
26 |     }
27 | 
28 |     /**
29 |      * @test
30 |      */
31 |     public function it_able_to_check_node_is_a_method(): void
32 |     {
33 |         $method = new ClassMethod(
34 |             name: 'getAllFoo',
35 |         );
36 | 
37 |         $isAVariable = NodeValidator::isAMethod($method);
38 | 
39 |         $this->assertTrue($isAVariable);
40 |     }
41 | 
42 |     /**
43 |      * @test
44 |      */
45 |     public function it_able_to_handle_an_unexpected_node(): void
46 |     {
47 |         $variable = new Array_(
48 |             items: [],
49 |             attributes: [],
50 |         );
51 | 
52 |         $isAVariable = NodeValidator::isAVariable($variable);
53 | 
54 |         $this->assertFalse($isAVariable);
55 |     }
56 | }
57 | 


--------------------------------------------------------------------------------