Add support template types

ReactiveX · Dec 2, 2023 · af34b8d · af34b8d
1 parent eee8eb2
commit af34b8d
Show file tree

Hide file tree

Showing 115 changed files with 1,679 additions and 381 deletions.
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
@@ -15,6 +15,7 @@ jobs:
           - ubuntu-20.04
           - windows-2019
         php:
+          - 8.3
           - 8.2
           - 8.1
           - 8.0
@@ -29,3 +30,28 @@ jobs:
           coverage: xdebug
       - run: composer install
       - run: vendor/bin/phpunit --coverage-text
+  PHPStan:
+    name: PHPStan (PHP ${{ matrix.php }} on ${{ matrix.os }})
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os:
+          - ubuntu-20.04
+          - windows-2019
+        php:
+          - 8.3
+          - 8.2
+          - 8.1
+          - 8.0
+          - 7.4
+          - 7.3
+          - 7.2
+    steps:
+      - uses: actions/checkout@v3
+      - uses: shivammathur/setup-php@v2
+        with:
+          php-version: ${{ matrix.php }}
+          coverage: none
+      - run: composer install
+      - run: vendor/bin/phpstan
diff --git a/composer.json b/composer.json
@@ -21,12 +21,13 @@
     ],
     "require": {
         "php": ">=7.0.0",
-        "react/promise": "^3 || ~2.2"
+        "react/promise": "^3"
     },
     "require-dev": {
         "satooshi/php-coveralls": "~1.0",
         "phpunit/phpunit": "^8.5 || ^9",
-        "react/event-loop": "^1.0 || ^0.5 || ^0.4.2"
+        "react/event-loop": "^1.0 || ^0.5 || ^0.4.2",
+        "phpstan/phpstan": "^1.10"
     },
     "suggest": {
         "react/event-loop": "Used for scheduling async operations"

diff --git a/phpstan.neon.dist b/phpstan.neon.dist
@@ -2,7 +2,8 @@ parameters:
     level: max
 
     paths:
+        - src/
         - test/types/
 
     fileExtensions:
-        - php
+        - php
diff --git a/src/Disposable/BinaryDisposable.php b/src/Disposable/BinaryDisposable.php
@@ -12,19 +12,19 @@
  */
 class BinaryDisposable implements DisposableInterface
 {
-    /** @var \Rx\DisposableInterface */
+    /** @var ?\Rx\DisposableInterface */
     private $first;
 
-    /** @var \Rx\DisposableInterface */
+    /** @var ?\Rx\DisposableInterface */
     private $second;
 
     /** @var bool */
     protected $isDisposed = false;
 
     /**
      * BinaryDisposable constructor.
-     * @param $first
-     * @param $second
+     * @param DisposableInterface $first
+     * @param DisposableInterface $second
      */
     public function __construct(DisposableInterface $first, DisposableInterface $second)
     {
@@ -40,7 +40,9 @@ public function dispose()
 
         $this->isDisposed = true;
 
+        /** @phpstan-ignore-next-line */
         $this->first->dispose();
+        /** @phpstan-ignore-next-line */
         $this->second->dispose();
 
         $this->first  = null;

diff --git a/src/Disposable/CallbackDisposable.php b/src/Disposable/CallbackDisposable.php
@@ -8,7 +8,14 @@
 
 class CallbackDisposable implements DisposableInterface
 {
+    /**
+     * @var callable
+     */
     private $action;
+
+    /**
+     * @var bool
+     */
     private $disposed = false;
 
     public function __construct(callable $action)

diff --git a/src/Disposable/CompositeDisposable.php b/src/Disposable/CompositeDisposable.php
@@ -8,9 +8,19 @@
 
 class CompositeDisposable implements DisposableInterface
 {
+    /**
+     * @var array<DisposableInterface>
+     */
     private $disposables;
+
+    /**
+     * @var bool
+     */
     private $isDisposed = false;
 
+    /**
+     * @param array<DisposableInterface> $disposables
+     */
     public function __construct(array $disposables = [])
     {
         $this->disposables = $disposables;
@@ -32,6 +42,9 @@ public function dispose()
         }
     }
 
+    /**
+     * @return void
+     */
     public function add(DisposableInterface $disposable)
     {
         if ($this->isDisposed) {
@@ -65,11 +78,17 @@ public function contains(DisposableInterface $disposable): bool
         return in_array($disposable, $this->disposables, true);
     }
 
+    /**
+     * @return int
+     */
     public function count()
     {
         return count($this->disposables);
     }
 
+    /**
+     * @return void
+     */
     public function clear()
     {
         $disposables       = $this->disposables;

diff --git a/src/Disposable/RefCountDisposable.php b/src/Disposable/RefCountDisposable.php
@@ -8,9 +8,24 @@
 
 class RefCountDisposable implements DisposableInterface
 {
+    /**
+     * @var int
+     */
     private $count = 0;
+
+    /**
+     * @var DisposableInterface
+     */
     private $disposable;
+
+    /**
+     * @var bool
+     */
     private $isDisposed = false;
+
+    /**
+     * @var bool
+     */
     private $isPrimaryDisposed = false;
 
     public function __construct(DisposableInterface $disposable)
@@ -32,6 +47,9 @@ public function dispose()
         }
     }
 
+    /**
+     * @return DisposableInterface
+     */
     public function getDisposable()
     {
         if (!$this->isDisposed) {

diff --git a/src/Disposable/SerialDisposable.php b/src/Disposable/SerialDisposable.php
@@ -15,7 +15,7 @@ class SerialDisposable implements DisposableInterface
     /** @var bool */
     private $isDisposed = false;
 
-    /** @var DisposableInterface */
+    /** @var ?DisposableInterface */
     private $disposable = null;
 
     public function dispose()
@@ -34,7 +34,7 @@ public function dispose()
     }
 
     /**
-     * @return DisposableInterface
+     * @return ?DisposableInterface
      */
     public function getDisposable()
     {
@@ -43,6 +43,7 @@ public function getDisposable()
 
     /**
      * @param DisposableInterface $disposable
+     * @return void
      */
     public function setDisposable(DisposableInterface $disposable)
     {

diff --git a/src/Disposable/SingleAssignmentDisposable.php b/src/Disposable/SingleAssignmentDisposable.php
@@ -9,7 +9,14 @@
 
 class SingleAssignmentDisposable implements DisposableInterface
 {
+    /**
+     * @var ?DisposableInterface
+     */
     private $current;
+
+    /**
+     * @var bool
+     */
     private $isDisposed = false;
 
     public function dispose()
@@ -27,6 +34,9 @@ public function dispose()
         }
     }
 
+    /**
+     * @return void
+     */
     public function setDisposable(DisposableInterface $disposable = null)
     {
         if ($this->current) {
@@ -42,11 +52,17 @@ public function setDisposable(DisposableInterface $disposable = null)
         }
     }
 
+    /**
+     * @return DisposableInterface|null
+     */
     public function getDisposable()
     {
         return $this->current;
     }
 
+    /**
+     * @return bool
+     */
     public function isDisposed()
     {
         return $this->isDisposed;

diff --git a/src/DisposableInterface.php b/src/DisposableInterface.php
@@ -6,5 +6,8 @@
 
 interface DisposableInterface
 {
+    /**
+     * @return void
+     */
     public function dispose();
 }
diff --git a/src/Notification.php b/src/Notification.php
@@ -9,33 +9,45 @@
  */
 abstract class Notification
 {
-    private $kind;
-
     /**
-     * @param mixed $kind Kind of notification
+     * @template T
+     * @param (callable(T): void)|ObserverInterface $observerOrOnNext
+     * @param (callable(\Throwable): void) $onError
+     * @param (callable(): void) $onCompleted
+     * @return void
      */
-    public function __construct($kind)
-    {
-        $this->kind = $kind;
-    }
-
-    public function accept($observerOrOnNext, $onError = null, $onCompleted = null)
+    public function accept($observerOrOnNext, callable $onError = null, callable $onCompleted = null)
     {
         if (null === $onError && null === $onCompleted && $observerOrOnNext instanceof ObserverInterface) {
             $this->doAcceptObservable($observerOrOnNext);
 
             return;
         }
 
-        return $this->doAccept($observerOrOnNext, $onError, $onCompleted);
+        assert(is_callable($observerOrOnNext));
+        $this->doAccept($observerOrOnNext, $onError, $onCompleted);
     }
 
+    /**
+     * @param mixed $other
+     */
     public function equals($other): bool
     {
+        /** @phpstan-ignore-next-line */
         return (string)$this === (string)$other;
     }
 
+    /**
+     * @return void
+     */
     abstract protected function doAcceptObservable(ObserverInterface $observer);
 
-    abstract protected function doAccept($onNext, $onError, $onCompleted);
+    /**
+     * @template T
+     * @param (callable(T): void) $onNext
+     * @param (callable(\Throwable): void) $onError
+     * @param (callable(): void) $onCompleted
+     * @return void
+     */
+    abstract protected function doAccept(callable $onNext, callable $onError = null, callable $onCompleted = null);
 }
diff --git a/src/Notification/OnCompletedNotification.php b/src/Notification/OnCompletedNotification.php
@@ -9,18 +9,17 @@
 
 class OnCompletedNotification extends Notification
 {
-    public function __construct()
-    {
-        parent::__construct('C');
-    }
-
+    /**
+     * @return void
+     */
     protected function doAcceptObservable(ObserverInterface $observer)
     {
         $observer->onCompleted();
     }
 
-    protected function doAccept($onNext, $onError, $onCompleted)
+    protected function doAccept(callable $onNext, callable $onError = null, callable $onCompleted = null)
     {
+        assert(is_callable($onCompleted));
         $onCompleted();
     }
 

diff --git a/src/Notification/OnErrorNotification.php b/src/Notification/OnErrorNotification.php
@@ -9,22 +9,27 @@
 
 class OnErrorNotification extends Notification
 {
+    /**
+     * @var \Throwable
+     */
     private $exception;
 
     public function __construct(\Throwable $exception)
     {
-        parent::__construct('E');
-
         $this->exception = $exception;
     }
 
+    /**
+     * @return void
+     */
     protected function doAcceptObservable(ObserverInterface $observer)
     {
         $observer->onError($this->exception);
     }
 
-    protected function doAccept($onNext, $onError, $onCompleted)
+    protected function doAccept(callable $onNext, callable $onError = null, callable $onCompleted = null)
     {
+        assert(is_callable($onError));
         $onError($this->exception);
     }