Use different fs watchers

Author: seregazhuk

.travis.yml

@@ -2,22 +2,6 @@ language: php
 
 jobs:
   include:
-    - stage: "PHP7.2 - lowest"
-      php: 7.2
-      script:
-        - composer update -n --prefer-dist --prefer-lowest --no-suggest
-        - composer dump-autoload
-        - composer ci:tests
-        - composer ci:php:psalm
-
-    - stage: "PHP7.3 - highest"
-      php: 7.3
-      script:
-        - composer update -n --prefer-dist --no-suggest
-        - composer dump-autoload
-        - composer ci:tests
-        - composer ci:php:psalm
-
     - stage: "PHP7.4 - highest"
       php: 7.4
       script:

CHANGELOG.md

@@ -1,5 +1,7 @@
-## 0.6.0 (2020-05-11)
+## 0.6.0 (2020-05-20)
 * Fix: don't use child process for resource watching
+* Feature: add fswatch support
+* Fix: min required PHP version is set to 7.4
 
 ## 0.5.2 (2019-12-07)
 * Fix: use predefined const for PHP binary [#59](https://github.com/seregazhuk/php-watcher/pull/59)

composer.json

@@ -24,7 +24,7 @@
         }
     ],
     "require": {
-        "php": "^7.2",
+        "php": "^7.4",
         "ext-json": "*",
         "ext-pcntl": "*",
         "yosymfony/resource-watcher": "^2.0",
@@ -34,7 +34,8 @@
         "react/child-process": "^0.6.1",
         "react/stream": "^1.0.0",
         "symfony/finder": "^4.3 || ^5.0",
-        "alecrabbit/php-cli-snake": "^0.5"
+        "alecrabbit/php-cli-snake": "^0.5",
+        "seregazhuk/reactphp-fswatch": "^0.1.0"
     },
     "autoload": {
         "psr-4": {

phpunit.xml.dist

@@ -16,9 +16,6 @@
     <filter>
         <whitelist processUncoveredFilesFromWhitelist="true">
             <directory suffix=".php">src</directory>
-            <exclude>
-                <file>src/Filesystem/watcher.php</file>
-            </exclude>
         </whitelist>
     </filter>
 </phpunit>

src/Filesystem/ChangesListener.php

@@ -1,13 +1,14 @@
 <?php
 
 declare(strict_types=1);
-namespace seregazhuk\PhpWatcher\Filesystem;
 
-use seregazhuk\PhpWatcher\Config\WatchList;
+namespace seregazhuk\PhpWatcher\Filesystem;
 
 interface ChangesListener
 {
-    public function start(WatchList $watchList): void;
+    public function start(): void;
 
     public function onChange(callable $callback): void;
+
+    public function stop(): void;
 }

src/Filesystem/Factory.php

@@ -0,0 +1,22 @@
+<?php
+
+declare(strict_types=1);
+
+namespace seregazhuk\PhpWatcher\Filesystem;
+
+use React\EventLoop\LoopInterface;
+use seregazhuk\PhpWatcher\Config\WatchList;
+use seregazhuk\PhpWatcher\Filesystem\FsWatchBased\ChangesListener as FsWatchBased;
+use seregazhuk\PhpWatcher\Filesystem\ResourceWatcherBased\ChangesListener as ResourceBased;
+
+final class Factory
+{
+    public static function create(WatchList $watchList, LoopInterface $loop): ChangesListener
+    {
+        if (FsWatchBased::isAvailable()) {
+            return new FsWatchBased($watchList, $loop);
+        }
+
+        return new ResourceBased($watchList, $loop);
+    }
+}

src/Filesystem/FsWatchBased/ChangesListener.php

@@ -0,0 +1,65 @@
+<?php
+
+declare(strict_types=1);
+
+namespace seregazhuk\PhpWatcher\Filesystem\FsWatchBased;
+
+use Evenement\EventEmitter;
+use React\EventLoop\LoopInterface;
+use seregazhuk\PhpWatcher\Config\WatchList;
+use seregazhuk\PhpWatcher\Filesystem\ChangesListener as ChangesListenerInterface;
+use Seregazhuk\ReactFsWatch\FsWatch;
+
+final class ChangesListener extends EventEmitter implements ChangesListenerInterface
+{
+    private FsWatch $fsWatch;
+
+    public function __construct(WatchList $watchList, LoopInterface $loop)
+    {
+        $this->fsWatch = new FsWatch($this->makeOptions($watchList), $loop);
+    }
+
+    public static function isAvailable(): bool
+    {
+        return FsWatch::isAvailable();
+    }
+
+    public function start(): void
+    {
+        $this->fsWatch->run();
+        $this->fsWatch->on(
+            'change',
+            function () {
+                $this->emit('change');
+            }
+        );
+    }
+
+    public function onChange(callable $callback): void
+    {
+        $this->on('change', $callback);
+    }
+
+    public function stop(): void
+    {
+        $this->fsWatch->stop();
+    }
+
+    private function makeOptions(WatchList $watchList): string
+    {
+        $options = [];
+        if ($watchList->ignore()) {
+            $options[] = implode('-e ', $watchList->ignore());
+        }
+
+        if ($watchList->fileExtensions()) {
+            $options[] = implode(' ', $watchList->fileExtensions());
+        }
+
+        if ($watchList->paths()) {
+            $options[] = implode(' ', $watchList->paths());
+        }
+
+        return implode(' ', $options);
+    }
+}

src/Filesystem/ResourceWatcherBased/ChangesListener.php

@@ -1,31 +1,35 @@
-<?php declare(strict_types=1);
+<?php
+
+declare(strict_types=1);
 
 namespace seregazhuk\PhpWatcher\Filesystem\ResourceWatcherBased;
 
 use Evenement\EventEmitter;
 use React\EventLoop\LoopInterface;
 use seregazhuk\PhpWatcher\Config\WatchList;
+use seregazhuk\PhpWatcher\Filesystem\ChangesListener as ChangesListenerInterface;
+use Yosymfony\ResourceWatcher\ResourceWatcher;
 
-final class ChangesListener extends EventEmitter implements
-    \seregazhuk\PhpWatcher\Filesystem\ChangesListener
+final class ChangesListener extends EventEmitter implements ChangesListenerInterface
 {
     private const INTERVAL = 0.15;
 
-    private $loop;
+    private LoopInterface $loop;
+
+    private ResourceWatcher $watcher;
 
-    public function __construct(LoopInterface $loop)
+    public function __construct(WatchList $watchList, LoopInterface $loop)
     {
         $this->loop = $loop;
+        $this->watcher = ResourceWatcherBuilder::create($watchList);
     }
 
-    public function start(WatchList $watchList): void
+    public function start(): void
     {
-        $watcher = ResourceWatcherBuilder::create($watchList);
-
         $this->loop->addPeriodicTimer(
             self::INTERVAL,
-            function () use ($watcher) {
-                if ($watcher->findChanges()->hasChanges()) {
+            function () {
+                if ($this->watcher->findChanges()->hasChanges()) {
                     $this->emit('change');
                 }
             }
@@ -36,4 +40,8 @@ public function onChange(callable $callback): void
     {
         $this->on('change', $callback);
     }
+
+    public function stop(): void
+    {
+    }
 }

src/Watcher.php

@@ -5,14 +5,13 @@
 namespace seregazhuk\PhpWatcher;
 
 use React\EventLoop\LoopInterface;
-use seregazhuk\PhpWatcher\Config\WatchList;
-use seregazhuk\PhpWatcher\Filesystem\ResourceWatcherBased\ChangesListener;
+use seregazhuk\PhpWatcher\Filesystem\ChangesListener;
 
 final class Watcher
 {
-    private $loop;
+    private LoopInterface $loop;
 
-    private $filesystemListener;
+    private ChangesListener $filesystemListener;
 
     public function __construct(LoopInterface $loop, ChangesListener $filesystemListener)
     {
@@ -22,13 +21,12 @@ public function __construct(LoopInterface $loop, ChangesListener $filesystemList
 
     public function startWatching(
         ProcessRunner $processRunner,
-        WatchList $watchList,
         int $signal,
         float $delayToRestart
     ): void {
         $processRunner->start();
 
-        $this->filesystemListener->start($watchList);
+        $this->filesystemListener->start();
         $this->filesystemListener->onChange(
             static function () use ($processRunner, $signal, $delayToRestart) {
                 $processRunner->stop($signal);

src/WatcherCommand.php

@@ -1,4 +1,5 @@
 <?php
+
 declare(strict_types=1);
 
 namespace seregazhuk\PhpWatcher;
@@ -9,7 +10,8 @@
 use seregazhuk\PhpWatcher\Config\Builder;
 use seregazhuk\PhpWatcher\Config\Config;
 use seregazhuk\PhpWatcher\Config\InputExtractor;
-use seregazhuk\PhpWatcher\Filesystem\ResourceWatcherBased\ChangesListener;
+use seregazhuk\PhpWatcher\Filesystem\Factory as ChangesListenerFactory;
+use seregazhuk\PhpWatcher\Filesystem\ChangesListener;
 use seregazhuk\PhpWatcher\Screen\Screen;
 use seregazhuk\PhpWatcher\Screen\SpinnerFactory;
 use Symfony\Component\Console\Command\Command as BaseCommand;
@@ -60,32 +62,36 @@ protected function execute(InputInterface $input, OutputInterface $output)
         $config = $this->buildConfig(new InputExtractor($input));
         $spinner = SpinnerFactory::create($output, $config->spinnerDisabled());
 
-        $this->addTerminationListeners($loop, $spinner);
 
         $screen = new Screen(new SymfonyStyle($input, $output), $spinner);
-        $filesystem = new ChangesListener($loop);
+        $filesystem = ChangesListenerFactory::create($config->watchList(), $loop);
 
         $screen->showOptions($config->watchList());
         $processRunner = new ProcessRunner($loop, $screen, $config->command());
 
         $watcher = new Watcher($loop, $filesystem);
         $watcher->startWatching(
             $processRunner,
-            $config->watchList(),
             $config->signalToReload(),
             $config->delay()
         );
 
+        $this->addTerminationListeners($loop, $spinner, $filesystem);
+
         return 0;
     }
 
     /**
      * When terminating the watcher we need to manually restore the cursor after the spinner.
      */
-    private function addTerminationListeners(LoopInterface $loop, SpinnerInterface $spinner): void
-    {
-        $func = static function (int $signal) use ($spinner): void {
+    private function addTerminationListeners(
+        LoopInterface $loop,
+        SpinnerInterface $spinner,
+        ChangesListener $changesListener
+    ): void {
+        $func = static function (int $signal) use ($spinner, $changesListener): void {
             $spinner->end();
+            $changesListener->stop();
             exit($signal);
         };