[1.x] Adds --dirty option (#130)

* Introduce `--dirty` for Git projects

* Fix path case

* Correct docblocks

* Removes extra line on .gitignore

* Applies minor coding style changes

* Updates description

* Use `app` instead of `resolve`

* Ignores excluded files

* Includes new files

* Removes `cut` and avoids styling deleted files

* Filter deleted and renamed files

* Update DefaultCommand.php

* Update DefaultCommand.php

Co-authored-by: Jason McCreary <jason@pureconcepts.net>
Co-authored-by: Taylor Otwell <taylor@laravel.com>

.gitignore

@@ -2,4 +2,3 @@
 /vendor
 composer.lock
 .phpunit.result.cache
-

app/Commands/DefaultCommand.php

@@ -38,6 +38,7 @@ protected function configure()
                     new InputOption('config', '', InputOption::VALUE_REQUIRED, 'The configuration that should be used'),
                     new InputOption('preset', '', InputOption::VALUE_REQUIRED, 'The preset that should be used'),
                     new InputOption('test', '', InputOption::VALUE_NONE, 'Test for code style errors without fixing them'),
+                    new InputOption('dirty', '', InputOption::VALUE_NONE, 'Only fix files that have uncommitted changes'),
                     new InputOption('format', '', InputOption::VALUE_REQUIRED, 'The output format that should be used'),
                 ]
             );

app/Contracts/PathsRepository.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace App\Contracts;
+
+interface PathsRepository
+{
+    /**
+     * Determine the "dirty" files.
+     *
+     * @return array<int, string>
+     */
+    public function dirty();
+}

app/Factories/ConfigurationFactory.php

@@ -41,6 +41,24 @@ class ConfigurationFactory
      * @return \PhpCsFixer\ConfigInterface
      */
     public static function preset($rules)
+    {
+        return (new Config())
+            ->setFinder(self::finder())
+            ->setRules(array_merge($rules, resolve(ConfigurationJsonRepository::class)->rules()))
+            ->setRiskyAllowed(true)
+            ->setUsingCache(true)
+            ->registerCustomFixers([
+                // Laravel...
+                new LaravelPhpdocAlignmentFixer(),
+            ]);
+    }
+
+    /**
+     * Creates the finder instance.
+     *
+     * @return \PhpCsFixer\Finder
+     */
+    public static function finder()
     {
         $localConfiguration = resolve(ConfigurationJsonRepository::class);
 
@@ -58,14 +76,6 @@ public static function preset($rules)
             $finder->{$method}($arguments);
         }
 
-        return (new Config())
-            ->setFinder($finder)
-            ->setRules(array_merge($rules, $localConfiguration->rules()))
-            ->setRiskyAllowed(true)
-            ->setUsingCache(true)
-            ->registerCustomFixers([
-                // Laravel...
-                new LaravelPhpdocAlignmentFixer(),
-            ]);
+        return $finder;
     }
 }

app/Factories/ConfigurationResolverFactory.php

@@ -2,8 +2,8 @@
 
 namespace App\Factories;
 
+use App\Project;
 use App\Repositories\ConfigurationJsonRepository;
-use App\Support\Project;
 use ArrayIterator;
 use PhpCsFixer\Config;
 use PhpCsFixer\Console\ConfigurationResolver;
@@ -32,7 +32,7 @@ class ConfigurationResolverFactory
      */
     public static function fromIO($input, $output)
     {
-        $path = $input->getArgument('path');
+        $path = Project::paths($input);
 
         $localConfiguration = resolve(ConfigurationJsonRepository::class);
 

app/Output/SummaryOutput.php

@@ -3,7 +3,7 @@
 namespace App\Output;
 
 use App\Output\Concerns\InteractsWithSymbols;
-use App\Support\Project;
+use App\Project;
 use App\ValueObjects\Issue;
 use PhpCsFixer\FixerFileProcessedEvent;
 use function Termwind\render;

app/Project.php

@@ -0,0 +1,49 @@
+<?php
+
+namespace App;
+
+use App\Contracts\PathsRepository;
+
+class Project
+{
+    /**
+     * Determine the project paths to apply the code style based on the options and arguments passed.
+     *
+     * @param  \Symfony\Component\Console\Input\InputInterface  $input
+     * @return array<int, string>
+     */
+    public static function paths($input)
+    {
+        if ($input->getOption('dirty')) {
+            return static::resolveDirtyPaths();
+        }
+
+        return $input->getArgument('path');
+    }
+
+    /**
+     * The project being analysed path.
+     *
+     * @return string
+     */
+    public static function path()
+    {
+        return getcwd();
+    }
+
+    /**
+     * Resolves the dirty paths, if any.
+     *
+     * @return array<int, string>
+     */
+    public static function resolveDirtyPaths()
+    {
+        $files = app(PathsRepository::class)->dirty();
+
+        if (empty($files)) {
+            abort(1, 'No dirty files found.');
+        }
+
+        return $files;
+    }
+}

app/Providers/RepositoriesServiceProvider.php

@@ -2,8 +2,10 @@
 
 namespace App\Providers;
 
+use App\Contracts\PathsRepository;
+use App\Project;
 use App\Repositories\ConfigurationJsonRepository;
-use App\Support\Project;
+use App\Repositories\GitPathsRepository;
 use Illuminate\Support\ServiceProvider;
 use Symfony\Component\Console\Input\InputInterface;
 
@@ -34,5 +36,11 @@ public function register()
                 $input->getOption('preset'),
             );
         });
+
+        $this->app->singleton(PathsRepository::class, function () {
+            return new GitPathsRepository(
+                Project::path(),
+            );
+        });
     }
 }

app/Repositories/GitPathsRepository.php

@@ -0,0 +1,57 @@
+<?php
+
+namespace App\Repositories;
+
+use App\Contracts\PathsRepository;
+use App\Factories\ConfigurationFactory;
+use Illuminate\Support\Str;
+use Symfony\Component\Process\Process;
+
+class GitPathsRepository implements PathsRepository
+{
+    /**
+     * The project path.
+     *
+     * @var string
+     */
+    protected $path;
+
+    /**
+     * Creates a new Paths Repository instance.
+     *
+     * @param  string  $path
+     */
+    public function __construct($path)
+    {
+        $this->path = $path;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function dirty()
+    {
+        $process = tap(new Process(['git', 'status', '--short', '--', '*.php']))->run();
+
+        if (! $process->isSuccessful()) {
+            abort(1, 'The [--dirty] option is only available when using Git.');
+        }
+
+        $dirtyFiles = collect(preg_split('/\R+/', $process->getOutput(), flags: PREG_SPLIT_NO_EMPTY))
+            ->mapWithKeys(fn ($file) => [substr($file, 3) => trim(substr($file, 0, 3))])
+            ->reject(fn ($status) => $status === 'D')
+            ->map(fn ($status, $file) => $status === 'R' ? Str::after($file, ' -> ') : $file)
+            ->map(fn ($file) => $this->path.DIRECTORY_SEPARATOR.$file)
+            ->values()
+            ->all();
+
+        $files = array_values(array_map(function ($splFile) {
+            return $splFile->getPathname();
+        }, iterator_to_array(ConfigurationFactory::finder()
+            ->in($this->path)
+            ->files()
+        )));
+
+        return array_values(array_intersect($files, $dirtyFiles));
+    }
+}

storage/framework/cache/.gitignore

@@ -0,0 +1,2 @@
+*
+!.gitignore

tests/Feature/DirtyTest.php

@@ -0,0 +1,57 @@
+<?php
+
+use App\Contracts\PathsRepository;
+
+it('determines dirty files', function () {
+    $paths = Mockery::mock(PathsRepository::class);
+
+    $paths
+        ->shouldReceive('dirty')
+        ->once()
+        ->andReturn([
+            base_path('tests/Fixtures/without-issues/file.php'),
+        ]);
+
+    $this->swap(PathsRepository::class, $paths);
+
+    [$statusCode, $output] = run('default', ['--dirty' => true]);
+
+    expect($statusCode)->toBe(0)
+        ->and($output)
+        ->toContain('── Laravel', ' 1 file');
+});
+
+it('ignores the path argument', function () {
+    $paths = Mockery::mock(PathsRepository::class);
+
+    $paths
+        ->shouldReceive('dirty')
+        ->once()
+        ->andReturn([
+            base_path('tests/Fixtures/without-issues/file.php'),
+        ]);
+
+    $this->swap(PathsRepository::class, $paths);
+
+    [$statusCode, $output] = run('default', [
+        '--dirty' => true,
+        'path' => base_path(),
+    ]);
+
+    expect($statusCode)->toBe(0)
+        ->and($output)
+        ->toContain('── Laravel', ' 1 file');
+});
+
+it('aborts when there are no dirty files', function () {
+    $paths = Mockery::mock(PathsRepository::class);
+
+    $paths
+        ->shouldReceive('dirty')
+        ->once()
+        ->andReturn([]);
+
+    $this->swap(PathsRepository::class, $paths);
+
+    run('default', ['--dirty' => true]);
+})->throws(Exception::class, 'No dirty files found.');

tests/Pest.php

@@ -61,10 +61,9 @@ function run($command, $arguments)
 
     if (isset($arguments['path'])) {
         $arguments['--config'] = $arguments['path'].'/pint.json';
+        $arguments['path'] = [$arguments['path']];
     }
 
-    $arguments['path'] = [$arguments['path']];
-
     $commandInstance = match ($command) {
         'default' => resolve(DefaultCommand::class),
     };