Thanks to visit codestin.com
Credit goes to github.com

Skip to content

Commit b4d469e

Browse files
derrabusderrabus
committed
Bump to PHP 8.1 and add types everywhere
1 parent 38a27fe commit b4d469e

7 files changed

Lines changed: 71 additions & 117 deletions

File tree

‎.github/workflows/continuous-integration.yml‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -13,4 +13,4 @@ jobs:
1313
name: "PHPUnit"
1414
uses: "doctrine/.github/.github/workflows/[email protected]"
1515
with:
16-
php-versions: '["7.1", "7.2", "7.3", "7.4", "8.0", "8.1", "8.2"]'
16+
php-versions: '["8.1", "8.2"]'

‎composer.json‎

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -20,13 +20,13 @@
2020
{"name": "Marco Pivetta", "email": "[email protected]"}
2121
],
2222
"require": {
23-
"php": "^7.1 || ^8.0"
23+
"php": "^8.1"
2424
},
2525
"require-dev": {
26-
"doctrine/coding-standard": "^9 || ^10",
27-
"phpstan/phpstan": "~1.4.10 || ^1.8.8",
28-
"phpunit/phpunit": "^7.5 || ^8.5 || ^9.5",
29-
"vimeo/psalm": "^4.24"
26+
"doctrine/coding-standard": "^10",
27+
"phpstan/phpstan": "^1.8.8",
28+
"phpunit/phpunit": "^9.5",
29+
"vimeo/psalm": "^4.28"
3030
},
3131
"conflict": {
3232
"doctrine/common": "<2.9"

‎phpcs.xml.dist‎

Lines changed: 1 addition & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -15,26 +15,7 @@
1515
<file>src</file>
1616
<file>tests</file>
1717

18-
<rule ref="Doctrine">
19-
<exclude name="SlevomatCodingStandard.TypeHints.DeclareStrictTypes"/>
20-
<exclude name="SlevomatCodingStandard.TypeHints.TypeHintDeclaration.MissingParameterTypeHint"/>
21-
<exclude name="SlevomatCodingStandard.TypeHints.TypeHintDeclaration.MissingReturnTypeHint"/>
22-
<exclude name="SlevomatCodingStandard.Exceptions.ReferenceThrowableOnly.ReferencedGeneralException"/>
23-
24-
<!-- Adding type hints breaks backward compatibility -->
25-
<exclude name="SlevomatCodingStandard.TypeHints.ReturnTypeHint.MissingNativeTypeHint"/>
26-
<exclude name="SlevomatCodingStandard.TypeHints.ParameterTypeHint.MissingNativeTypeHint"/>
27-
28-
<!-- The null coalesce equal operator is only available in PHP 7.4+ -->
29-
<exclude name="SlevomatCodingStandard.ControlStructures.RequireNullCoalesceEqualOperator"/>
30-
</rule>
31-
32-
<!-- Property type hints are only available in PHP 7.4+ -->
33-
<rule ref="SlevomatCodingStandard.TypeHints.PropertyTypeHint">
34-
<properties>
35-
<property name="enableNativeTypeHint" value="false"/>
36-
</properties>
37-
</rule>
18+
<rule ref="Doctrine" />
3819

3920
<rule ref="PSR1.Classes.ClassDeclaration.MultipleClasses">
4021
<exclude-pattern>tests/*</exclude-pattern>

‎src/EventArgs.php‎

Lines changed: 3 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -15,10 +15,8 @@ class EventArgs
1515
{
1616
/**
1717
* Single instance of EventArgs.
18-
*
19-
* @var EventArgs|null
2018
*/
21-
private static $_emptyEventArgsInstance;
19+
private static EventArgs|null $emptyEventArgsInstance = null;
2220

2321
/**
2422
* Gets the single, empty and immutable EventArgs instance.
@@ -31,15 +29,9 @@ class EventArgs
3129
*
3230
* @link https://msdn.microsoft.com/en-us/library/system.eventargs.aspx
3331
* @see EventManager::dispatchEvent
34-
*
35-
* @return EventArgs
3632
*/
37-
public static function getEmptyInstance()
33+
public static function getEmptyInstance(): EventArgs
3834
{
39-
if (! self::$_emptyEventArgsInstance) {
40-
self::$_emptyEventArgsInstance = new EventArgs();
41-
}
42-
43-
return self::$_emptyEventArgsInstance;
35+
return self::$emptyEventArgsInstance ??= new EventArgs();
4436
}
4537
}

‎src/EventManager.php‎

Lines changed: 23 additions & 36 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,7 @@
11
<?php
22

3+
declare(strict_types=1);
4+
35
namespace Doctrine\Common;
46

57
use function spl_object_hash;
@@ -17,7 +19,7 @@ class EventManager
1719
*
1820
* @var object[][]
1921
*/
20-
private $_listeners = [];
22+
private array $listeners = [];
2123

2224
/**
2325
* Dispatches an event to all registered listeners.
@@ -26,18 +28,16 @@ class EventManager
2628
* the name of the method that is invoked on listeners.
2729
* @param EventArgs|null $eventArgs The event arguments to pass to the event handlers/listeners.
2830
* If not supplied, the single empty EventArgs instance is used.
29-
*
30-
* @return void
3131
*/
32-
public function dispatchEvent($eventName, ?EventArgs $eventArgs = null)
32+
public function dispatchEvent(string $eventName, EventArgs|null $eventArgs = null): void
3333
{
34-
if (! isset($this->_listeners[$eventName])) {
34+
if (! isset($this->listeners[$eventName])) {
3535
return;
3636
}
3737

38-
$eventArgs = $eventArgs ?? EventArgs::getEmptyInstance();
38+
$eventArgs ??= EventArgs::getEmptyInstance();
3939

40-
foreach ($this->_listeners[$eventName] as $listener) {
40+
foreach ($this->listeners[$eventName] as $listener) {
4141
$listener->$eventName($eventArgs);
4242
}
4343
}
@@ -50,83 +50,70 @@ public function dispatchEvent($eventName, ?EventArgs $eventArgs = null)
5050
* @return object[]|object[][] The event listeners for the specified event, or all event listeners.
5151
* @psalm-return ($event is null ? object[][] : object[])
5252
*/
53-
public function getListeners($event = null)
53+
public function getListeners(string|null $event = null): array
5454
{
55-
return $event ? $this->_listeners[$event] : $this->_listeners;
55+
return $event ? $this->listeners[$event] : $this->listeners;
5656
}
5757

5858
/**
5959
* Checks whether an event has any registered listeners.
60-
*
61-
* @param string $event
62-
*
63-
* @return bool TRUE if the specified event has any listeners, FALSE otherwise.
6460
*/
65-
public function hasListeners($event)
61+
public function hasListeners(string $event): bool
6662
{
67-
return ! empty($this->_listeners[$event]);
63+
return ! empty($this->listeners[$event]);
6864
}
6965

7066
/**
7167
* Adds an event listener that listens on the specified events.
7268
*
7369
* @param string|string[] $events The event(s) to listen on.
7470
* @param object $listener The listener object.
75-
*
76-
* @return void
7771
*/
78-
public function addEventListener($events, $listener)
72+
public function addEventListener(string|array $events, object $listener): void
7973
{
8074
// Picks the hash code related to that listener
8175
$hash = spl_object_hash($listener);
8276

8377
foreach ((array) $events as $event) {
8478
// Overrides listener if a previous one was associated already
8579
// Prevents duplicate listeners on same event (same instance only)
86-
$this->_listeners[$event][$hash] = $listener;
80+
$this->listeners[$event][$hash] = $listener;
8781
}
8882
}
8983

9084
/**
9185
* Removes an event listener from the specified events.
9286
*
9387
* @param string|string[] $events
94-
* @param object $listener
95-
*
96-
* @return void
9788
*/
98-
public function removeEventListener($events, $listener)
89+
public function removeEventListener(string|array $events, object $listener): void
9990
{
10091
// Picks the hash code related to that listener
10192
$hash = spl_object_hash($listener);
10293

10394
foreach ((array) $events as $event) {
104-
unset($this->_listeners[$event][$hash]);
95+
unset($this->listeners[$event][$hash]);
10596
}
10697
}
10798

10899
/**
109-
* Adds an EventSubscriber. The subscriber is asked for all the events it is
110-
* interested in and added as a listener for these events.
100+
* Adds an EventSubscriber.
111101
*
112-
* @param EventSubscriber $subscriber The subscriber.
113-
*
114-
* @return void
102+
* The subscriber is asked for all the events it is interested in and added
103+
* as a listener for these events.
115104
*/
116-
public function addEventSubscriber(EventSubscriber $subscriber)
105+
public function addEventSubscriber(EventSubscriber $subscriber): void
117106
{
118107
$this->addEventListener($subscriber->getSubscribedEvents(), $subscriber);
119108
}
120109

121110
/**
122-
* Removes an EventSubscriber. The subscriber is asked for all the events it is
123-
* interested in and removed as a listener for these events.
124-
*
125-
* @param EventSubscriber $subscriber The subscriber.
111+
* Removes an EventSubscriber.
126112
*
127-
* @return void
113+
* The subscriber is asked for all the events it is interested in and removed
114+
* as a listener for these events.
128115
*/
129-
public function removeEventSubscriber(EventSubscriber $subscriber)
116+
public function removeEventSubscriber(EventSubscriber $subscriber): void
130117
{
131118
$this->removeEventListener($subscriber->getSubscribedEvents(), $subscriber);
132119
}

‎src/EventSubscriber.php‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -17,5 +17,5 @@ interface EventSubscriber
1717
*
1818
* @return string[]
1919
*/
20-
public function getSubscribedEvents();
20+
public function getSubscribedEvents(): array;
2121
}

‎tests/EventManagerTest.php‎

Lines changed: 37 additions & 43 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,7 @@
11
<?php
22

3+
declare(strict_types=1);
4+
35
namespace Doctrine\Tests\Common;
46

57
use Doctrine\Common\EventArgs;
@@ -17,79 +19,73 @@ class EventManagerTest extends TestCase
1719
private const POST_FOO = 'postFoo';
1820
private const PRE_BAR = 'preBar';
1921

20-
/** @var bool */
21-
private $_preFooInvoked = false;
22-
23-
/** @var bool */
24-
private $_postFooInvoked = false;
25-
26-
/** @var EventManager */
27-
private $_eventManager;
22+
private bool $preFooInvoked = false;
23+
private bool $postFooInvoked = false;
24+
private EventManager $eventManager;
2825

2926
protected function setUp(): void
3027
{
31-
$this->_eventManager = new EventManager();
32-
$this->_preFooInvoked = false;
33-
$this->_postFooInvoked = false;
28+
$this->eventManager = new EventManager();
29+
$this->preFooInvoked = false;
30+
$this->postFooInvoked = false;
3431
}
3532

3633
public function testInitialState(): void
3734
{
38-
self::assertEquals([], $this->_eventManager->getListeners());
39-
self::assertFalse($this->_eventManager->hasListeners(self::PRE_FOO));
40-
self::assertFalse($this->_eventManager->hasListeners(self::POST_FOO));
35+
self::assertEquals([], $this->eventManager->getListeners());
36+
self::assertFalse($this->eventManager->hasListeners(self::PRE_FOO));
37+
self::assertFalse($this->eventManager->hasListeners(self::POST_FOO));
4138
}
4239

4340
public function testAddEventListener(): void
4441
{
45-
$this->_eventManager->addEventListener(['preFoo', 'postFoo'], $this);
46-
self::assertTrue($this->_eventManager->hasListeners(self::PRE_FOO));
47-
self::assertTrue($this->_eventManager->hasListeners(self::POST_FOO));
48-
self::assertEquals(1, count($this->_eventManager->getListeners(self::PRE_FOO)));
49-
self::assertEquals(1, count($this->_eventManager->getListeners(self::POST_FOO)));
50-
self::assertEquals(2, count($this->_eventManager->getListeners()));
42+
$this->eventManager->addEventListener(['preFoo', 'postFoo'], $this);
43+
self::assertTrue($this->eventManager->hasListeners(self::PRE_FOO));
44+
self::assertTrue($this->eventManager->hasListeners(self::POST_FOO));
45+
self::assertEquals(1, count($this->eventManager->getListeners(self::PRE_FOO)));
46+
self::assertEquals(1, count($this->eventManager->getListeners(self::POST_FOO)));
47+
self::assertEquals(2, count($this->eventManager->getListeners()));
5148
}
5249

5350
public function testDispatchEvent(): void
5451
{
55-
$this->_eventManager->addEventListener(['preFoo', 'postFoo'], $this);
56-
$this->_eventManager->dispatchEvent(self::PRE_FOO);
57-
self::assertTrue($this->_preFooInvoked);
58-
self::assertFalse($this->_postFooInvoked);
52+
$this->eventManager->addEventListener(['preFoo', 'postFoo'], $this);
53+
$this->eventManager->dispatchEvent(self::PRE_FOO);
54+
self::assertTrue($this->preFooInvoked);
55+
self::assertFalse($this->postFooInvoked);
5956
}
6057

6158
public function testRemoveEventListener(): void
6259
{
63-
$this->_eventManager->addEventListener(['preBar'], $this);
64-
self::assertTrue($this->_eventManager->hasListeners(self::PRE_BAR));
65-
$this->_eventManager->removeEventListener(['preBar'], $this);
66-
self::assertFalse($this->_eventManager->hasListeners(self::PRE_BAR));
60+
$this->eventManager->addEventListener(['preBar'], $this);
61+
self::assertTrue($this->eventManager->hasListeners(self::PRE_BAR));
62+
$this->eventManager->removeEventListener(['preBar'], $this);
63+
self::assertFalse($this->eventManager->hasListeners(self::PRE_BAR));
6764
}
6865

6966
public function testAddEventSubscriber(): void
7067
{
7168
$eventSubscriber = new TestEventSubscriber();
72-
$this->_eventManager->addEventSubscriber($eventSubscriber);
73-
self::assertTrue($this->_eventManager->hasListeners(self::PRE_FOO));
74-
self::assertTrue($this->_eventManager->hasListeners(self::POST_FOO));
69+
$this->eventManager->addEventSubscriber($eventSubscriber);
70+
self::assertTrue($this->eventManager->hasListeners(self::PRE_FOO));
71+
self::assertTrue($this->eventManager->hasListeners(self::POST_FOO));
7572
}
7673

7774
public function testRemoveEventSubscriber(): void
7875
{
7976
$eventSubscriber = new TestEventSubscriber();
80-
$this->_eventManager->addEventSubscriber($eventSubscriber);
81-
$this->_eventManager->removeEventSubscriber($eventSubscriber);
82-
self::assertFalse($this->_eventManager->hasListeners(self::PRE_FOO));
83-
self::assertFalse($this->_eventManager->hasListeners(self::POST_FOO));
77+
$this->eventManager->addEventSubscriber($eventSubscriber);
78+
$this->eventManager->removeEventSubscriber($eventSubscriber);
79+
self::assertFalse($this->eventManager->hasListeners(self::PRE_FOO));
80+
self::assertFalse($this->eventManager->hasListeners(self::POST_FOO));
8481
}
8582

8683
public function testNoDispatchingForUnregisteredEvent(): void
8784
{
88-
$reflection = new ReflectionProperty(EventArgs::class, '_emptyEventArgsInstance');
89-
$reflection->setAccessible(true);
85+
$reflection = new ReflectionProperty(EventArgs::class, 'emptyEventArgsInstance');
9086
$reflection->setValue(null, null);
9187

92-
$this->_eventManager->dispatchEvent('unknown');
88+
$this->eventManager->dispatchEvent('unknown');
9389

9490
self::assertNull($reflection->getValue(null));
9591
}
@@ -98,20 +94,18 @@ public function testNoDispatchingForUnregisteredEvent(): void
9894

9995
public function preFoo(EventArgs $e): void
10096
{
101-
$this->_preFooInvoked = true;
97+
$this->preFooInvoked = true;
10298
}
10399

104100
public function postFoo(EventArgs $e): void
105101
{
106-
$this->_postFooInvoked = true;
102+
$this->postFooInvoked = true;
107103
}
108104
}
109105

110106
class TestEventSubscriber implements EventSubscriber
111107
{
112-
/**
113-
* @return string[]
114-
*/
108+
/** @return string[] */
115109
public function getSubscribedEvents(): array
116110
{
117111
return ['preFoo', 'postFoo'];

0 commit comments

Comments
 (0)