Exceptions are thrown when there is no catch() function (#60)

* wip: allow null results

* test: add failing test for #56

* feature: implement & test non-caught exceptions
closes #56

* test: reduce computational complexity

Author: Greg Bowler

src/Promise.php

@@ -9,16 +9,18 @@
 
 class Promise implements PromiseInterface {
 	private mixed $resolvedValue;
-	private ?Throwable $rejectedReason;
+	private Throwable $rejectedReason;
 
 	/** @var Chainable[] */
 	private array $chain;
 	/** @var CatchChain[] */
 	private array $uncalledCatchChain;
 	/** @var callable */
 	private $executor;
+	private bool $completed;
 
 	public function __construct(callable $executor) {
+		$this->completed = false;
 		$this->chain = [];
 		$this->uncalledCatchChain = [];
 
@@ -90,7 +92,7 @@ function(Throwable $reason) {
 				$this->reject($reason);
 			},
 			function() {
-				$this->complete();
+				$this->tryComplete();
 			}
 		);
 	}
@@ -121,17 +123,15 @@ private function reset():void {
 	}
 
 	private function tryComplete():void {
+		if($this->completed) {
+			return;
+		}
 		if($this->getState() !== PromiseState::PENDING) {
 			$this->complete();
 		}
 	}
 
 	private function complete():void {
-		$this->sortChain();
-		$this->handleChain();
-	}
-
-	private function sortChain():void {
 		usort(
 			$this->chain,
 			function(Chainable $a, Chainable $b) {
@@ -145,12 +145,10 @@ function(Chainable $a, Chainable $b) {
 				return 0;
 			}
 		);
-	}
-
-	private function handleChain():void {
 		$handledRejections = [];
 
 		$emptyChain = empty($this->chain);
+		$originalChain = $this->chain;
 		while($this->getState() !== PromiseState::PENDING) {
 			$chainItem = $this->getNextChainItem();
 			if(!$chainItem) {
@@ -170,7 +168,9 @@ private function handleChain():void {
 			}
 		}
 
-		$this->processHandledRejections($handledRejections, $emptyChain);
+		$this->handleCatches($originalChain, $emptyChain, $handledRejections);
+
+		$this->completed = true;
 	}
 
 	private function getNextChainItem():?Chainable {
@@ -184,7 +184,7 @@ private function handleThen(ThenChain $then):void {
 
 		try {
 			$result = $then->callOnResolved($this->resolvedValue)
-				?? $this->resolvedValue;
+				?? $this->resolvedValue ?? null;
 
 			if($result instanceof PromiseInterface) {
 				$this->chainPromise($result);
@@ -244,13 +244,29 @@ private function handleFinally(FinallyChain $finally):void {
 		}
 	}
 
-	/** @param array<Throwable> $handledRejections */
-	private function processHandledRejections(
+	/**
+	 * @param array<Chainable> $chain
+	 * @param bool $emptyChain
+	 * @param array<Throwable> $handledRejections
+	 */
+	protected function handleCatches(
+		array $chain,
+		bool $emptyChain,
 		array $handledRejections,
-		bool $emptyChain
 	):void {
-		if(isset($this->rejectedReason)) {
-			if(!$emptyChain && !in_array($this->rejectedReason, $handledRejections)) {
+		if ($this->getState() === PromiseState::REJECTED) {
+			$hasCatch = false;
+			foreach ($chain as $chainItem) {
+				if ($chainItem instanceof CatchChain) {
+					$hasCatch = true;
+				}
+			}
+
+			if (!$hasCatch) {
+				throw $this->rejectedReason;
+			}
+
+			if (!$emptyChain && !in_array($this->rejectedReason, $handledRejections)) {
 				throw $this->rejectedReason;
 			}
 		}

test/phpunit/PromiseTest.php

@@ -445,8 +445,10 @@ public function testGetStateFulfilled() {
 
 	public function testGetStateRejected() {
 		$promiseContainer = $this->getTestPromiseContainer();
-		$promiseContainer->reject(new Exception("Example rejection"));
 		$sut = $promiseContainer->getPromise();
+		$sut->catch(function(Throwable $throwable){});
+
+		$promiseContainer->reject(new Exception("Example rejection"));
 
 		self::assertEquals(
 			PromiseState::REJECTED,
@@ -488,12 +490,35 @@ public function testNoCatchMethodBubblesThrowables() {
 		$expectedException = new Exception("Test exception");
 		$promiseContainer = $this->getTestPromiseContainer();
 		$sut = $promiseContainer->getPromise();
+		$sut->then(function() use($expectedException) {
+			throw $expectedException;
+		});
 
 		$exception = null;
 		try {
-			$sut->then(function() use($expectedException) {
-				throw $expectedException;
+			$promiseContainer->resolve("test");
+		}
+		catch(Throwable $exception) {}
+
+		self::assertSame($expectedException, $exception);
+	}
+
+	public function testNoCatchMethodBubblesThrowables_internalRejection() {
+		$expectedException = new Exception("Test exception");
+		$promiseContainer = $this->getTestPromiseContainer();
+		$sut = $promiseContainer->getPromise();
+
+		$exception = null;
+		try {
+			$sut->then(function(string $message) use($sut, $promiseContainer, $expectedException) {
+				$sut->then(function($resolvedValue) use($promiseContainer, $expectedException) {
+					$promiseContainer->reject($expectedException);
+				});
+				return $sut;
+			})->catch(function(Throwable $reason) {
+				var_dump($reason);die("THIS IS THE REASON");
 			});
+
 			$promiseContainer->resolve("test");
 		}
 		catch(Throwable $exception) {}
@@ -641,7 +666,7 @@ public function testCustomPromise_reject() {
 
 		$customPromise->then(function($resolvedValue)use(&$resolution) {
 			$resolution = $resolvedValue;
-		}, function($rejectedValue)use(&$rejection) {
+		})->catch(function($rejectedValue)use(&$rejection) {
 			$rejection = $rejectedValue;
 		});
 
@@ -684,6 +709,41 @@ public function testPromise_rejectChain() {
 		self::assertCount(1, $catchCalls);
 	}
 
+	public function testPromise_notThrowWhenNoCatch():void {
+		$expectedException = new RuntimeException("This should be passed to the catch function");
+		$caughtReasons = [];
+
+		$deferred = new Deferred();
+		$deferredPromise = $deferred->getPromise();
+		$deferredPromise->then(function(string $message) use ($expectedException) {
+			if($message === "error") {
+				throw $expectedException;
+			}
+		})->catch(function(Throwable $reason) use(&$caughtReasons) {
+			array_push($caughtReasons, $reason);
+		});
+
+		$deferred->resolve("error");
+		self::assertCount(1, $caughtReasons);
+		self::assertSame($expectedException, $caughtReasons[0]);
+	}
+
+	public function testPromise_throwWhenNoCatch():void {
+		$expectedException = new RuntimeException("There was an error!");
+
+		$deferred = new Deferred();
+		$deferredPromise = $deferred->getPromise();
+		$deferredPromise->then(function(string $message) use($expectedException) {
+			if($message === "error") {
+				throw $expectedException;
+			}
+		});
+
+		self::expectException(RuntimeException::class);
+		self::expectExceptionMessage("There was an error!");
+		$deferred->resolve("error");
+	}
+
 	protected function getTestPromiseContainer():TestPromiseContainer {
 		$resolveCallback = null;
 		$rejectCallback = null;