Skip to content

Commit 2866134

Browse files
WyriHaximusWyriHaximus
committed
Update PHP language syntax and remove legacy workarounds
1 parent 1f68392 commit 2866134

16 files changed

+123
-133
lines changed

‎README.md

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -353,7 +353,7 @@ By default, this will call `end()` on the destination stream once the
353353
source stream emits an `end` event. This can be disabled like this:
354354

355355
```php
356-
$source->pipe($dest, array('end' => false));
356+
$source->pipe($dest, ['end' => false]);
357357
```
358358

359359
Note that this only applies to the `end` event.
@@ -1126,7 +1126,7 @@ $through = new ThroughStream(function ($data) {
11261126
});
11271127
$through->on('data', $this->expectCallableOnceWith("[2, true]\n"));
11281128

1129-
$through->write(array(2, true));
1129+
$through->write([2, true]);
11301130
```
11311131

11321132
The callback function is allowed to throw an `Exception`. In this case,

‎src/CompositeStream.php

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -20,11 +20,11 @@ public function __construct(ReadableStreamInterface $readable, WritableStreamInt
2020
return;
2121
}
2222

23-
Util::forwardEvents($this->readable, $this, array('data', 'end', 'error'));
24-
Util::forwardEvents($this->writable, $this, array('drain', 'error', 'pipe'));
23+
Util::forwardEvents($this->readable, $this, ['data', 'end', 'error']);
24+
Util::forwardEvents($this->writable, $this, ['drain', 'error', 'pipe']);
2525

26-
$this->readable->on('close', array($this, 'close'));
27-
$this->writable->on('close', array($this, 'close'));
26+
$this->readable->on('close', [$this, 'close']);
27+
$this->writable->on('close', [$this, 'close']);
2828
}
2929

3030
public function isReadable()
@@ -46,7 +46,7 @@ public function resume()
4646
$this->readable->resume();
4747
}
4848

49-
public function pipe(WritableStreamInterface $dest, array $options = array())
49+
public function pipe(WritableStreamInterface $dest, array $options = [])
5050
{
5151
return Util::pipe($this, $dest, $options);
5252
}

‎src/DuplexResourceStream.php

Lines changed: 16 additions & 46 deletions
Original file line numberDiff line numberDiff line change
@@ -59,14 +59,9 @@ public function __construct($stream, LoopInterface $loop = null, $readChunkSize
5959
// Use unbuffered read operations on the underlying stream resource.
6060
// Reading chunks from the stream may otherwise leave unread bytes in
6161
// PHP's stream buffers which some event loop implementations do not
62-
// trigger events on (edge triggered).
63-
// This does not affect the default event loop implementation (level
64-
// triggered), so we can ignore platforms not supporting this (HHVM).
65-
// Pipe streams (such as STDIN) do not seem to require this and legacy
66-
// PHP versions cause SEGFAULTs on unbuffered pipe streams, so skip this.
67-
if (\function_exists('stream_set_read_buffer') && !$this->isLegacyPipe($stream)) {
68-
\stream_set_read_buffer($stream, 0);
69-
}
62+
// trigger events on (edge triggered). This does not affect the default
63+
// event loop implementation (level triggered).
64+
\stream_set_read_buffer($stream, 0);
7065

7166
if ($buffer === null) {
7267
$buffer = new WritableResourceStream($stream, $loop);
@@ -77,16 +72,14 @@ public function __construct($stream, LoopInterface $loop = null, $readChunkSize
7772
$this->bufferSize = ($readChunkSize === null) ? 65536 : (int)$readChunkSize;
7873
$this->buffer = $buffer;
7974

80-
$that = $this;
81-
82-
$this->buffer->on('error', function ($error) use ($that) {
83-
$that->emit('error', array($error));
75+
$this->buffer->on('error', function ($error) {
76+
$this->emit('error', [$error]);
8477
});
8578

86-
$this->buffer->on('close', array($this, 'close'));
79+
$this->buffer->on('close', [$this, 'close']);
8780

88-
$this->buffer->on('drain', function () use ($that) {
89-
$that->emit('drain');
81+
$this->buffer->on('drain', function () {
82+
$this->emit('drain');
9083
});
9184

9285
$this->resume();
@@ -113,7 +106,9 @@ public function pause()
113106
public function resume()
114107
{
115108
if (!$this->listening && $this->readable) {
116-
$this->loop->addReadStream($this->stream, array($this, 'handleData'));
109+
$this->loop->addReadStream($this->stream, function () {
110+
$this->handleData();
111+
});
117112
$this->listening = true;
118113
}
119114
}
@@ -163,13 +158,12 @@ public function end($data = null)
163158
$this->buffer->end($data);
164159
}
165160

166-
public function pipe(WritableStreamInterface $dest, array $options = array())
161+
public function pipe(WritableStreamInterface $dest, array $options = [])
167162
{
168163
return Util::pipe($this, $dest, $options);
169164
}
170165

171-
/** @internal */
172-
public function handleData($stream)
166+
private function handleData()
173167
{
174168
$error = null;
175169
\set_error_handler(function ($errno, $errstr, $errfile, $errline) use (&$error) {
@@ -182,46 +176,22 @@ public function handleData($stream)
182176
);
183177
});
184178

185-
$data = \stream_get_contents($stream, $this->bufferSize);
179+
$data = \stream_get_contents($this->stream, $this->bufferSize);
186180

187181
\restore_error_handler();
188182

189183
if ($error !== null) {
190-
$this->emit('error', array(new \RuntimeException('Unable to read from stream: ' . $error->getMessage(), 0, $error)));
184+
$this->emit('error', [new \RuntimeException('Unable to read from stream: ' . $error->getMessage(), 0, $error)]);
191185
$this->close();
192186
return;
193187
}
194188

195189
if ($data !== '') {
196-
$this->emit('data', array($data));
190+
$this->emit('data', [$data]);
197191
} elseif (\feof($this->stream)) {
198192
// no data read => we reached the end and close the stream
199193
$this->emit('end');
200194
$this->close();
201195
}
202196
}
203-
204-
/**
205-
* Returns whether this is a pipe resource in a legacy environment
206-
*
207-
* This works around a legacy PHP bug (#61019) that was fixed in PHP 5.4.28+
208-
* and PHP 5.5.12+ and newer.
209-
*
210-
* @param resource $resource
211-
* @return bool
212-
* @link https://github.com/reactphp/child-process/issues/40
213-
*
214-
* @codeCoverageIgnore
215-
*/
216-
private function isLegacyPipe($resource)
217-
{
218-
if (\PHP_VERSION_ID < 50428 || (\PHP_VERSION_ID >= 50500 && \PHP_VERSION_ID < 50512)) {
219-
$meta = \stream_get_meta_data($resource);
220-
221-
if (isset($meta['stream_type']) && $meta['stream_type'] === 'STDIO') {
222-
return true;
223-
}
224-
}
225-
return false;
226-
}
227197
}

‎src/ReadableResourceStream.php

Lines changed: 10 additions & 38 deletions
Original file line numberDiff line numberDiff line change
@@ -61,14 +61,9 @@ public function __construct($stream, LoopInterface $loop = null, $readChunkSize
6161
// Use unbuffered read operations on the underlying stream resource.
6262
// Reading chunks from the stream may otherwise leave unread bytes in
6363
// PHP's stream buffers which some event loop implementations do not
64-
// trigger events on (edge triggered).
65-
// This does not affect the default event loop implementation (level
66-
// triggered), so we can ignore platforms not supporting this (HHVM).
67-
// Pipe streams (such as STDIN) do not seem to require this and legacy
68-
// PHP versions cause SEGFAULTs on unbuffered pipe streams, so skip this.
69-
if (\function_exists('stream_set_read_buffer') && !$this->isLegacyPipe($stream)) {
70-
\stream_set_read_buffer($stream, 0);
71-
}
64+
// trigger events on (edge triggered). This does not affect the default
65+
// event loop implementation (level triggered).
66+
\stream_set_read_buffer($stream, 0);
7267

7368
$this->stream = $stream;
7469
$this->loop = $loop ?: Loop::get();
@@ -93,12 +88,14 @@ public function pause()
9388
public function resume()
9489
{
9590
if (!$this->listening && !$this->closed) {
96-
$this->loop->addReadStream($this->stream, array($this, 'handleData'));
91+
$this->loop->addReadStream($this->stream, function () {
92+
$this->handleData();
93+
});
9794
$this->listening = true;
9895
}
9996
}
10097

101-
public function pipe(WritableStreamInterface $dest, array $options = array())
98+
public function pipe(WritableStreamInterface $dest, array $options = [])
10299
{
103100
return Util::pipe($this, $dest, $options);
104101
}
@@ -120,8 +117,7 @@ public function close()
120117
}
121118
}
122119

123-
/** @internal */
124-
public function handleData()
120+
private function handleData()
125121
{
126122
$error = null;
127123
\set_error_handler(function ($errno, $errstr, $errfile, $errline) use (&$error) {
@@ -139,41 +135,17 @@ public function handleData()
139135
\restore_error_handler();
140136

141137
if ($error !== null) {
142-
$this->emit('error', array(new \RuntimeException('Unable to read from stream: ' . $error->getMessage(), 0, $error)));
138+
$this->emit('error', [new \RuntimeException('Unable to read from stream: ' . $error->getMessage(), 0, $error)]);
143139
$this->close();
144140
return;
145141
}
146142

147143
if ($data !== '') {
148-
$this->emit('data', array($data));
144+
$this->emit('data', [$data]);
149145
} elseif (\feof($this->stream)) {
150146
// no data read => we reached the end and close the stream
151147
$this->emit('end');
152148
$this->close();
153149
}
154150
}
155-
156-
/**
157-
* Returns whether this is a pipe resource in a legacy environment
158-
*
159-
* This works around a legacy PHP bug (#61019) that was fixed in PHP 5.4.28+
160-
* and PHP 5.5.12+ and newer.
161-
*
162-
* @param resource $resource
163-
* @return bool
164-
* @link https://github.com/reactphp/child-process/issues/40
165-
*
166-
* @codeCoverageIgnore
167-
*/
168-
private function isLegacyPipe($resource)
169-
{
170-
if (\PHP_VERSION_ID < 50428 || (\PHP_VERSION_ID >= 50500 && \PHP_VERSION_ID < 50512)) {
171-
$meta = \stream_get_meta_data($resource);
172-
173-
if (isset($meta['stream_type']) && $meta['stream_type'] === 'STDIO') {
174-
return true;
175-
}
176-
}
177-
return false;
178-
}
179151
}

‎src/ReadableStreamInterface.php

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -278,7 +278,7 @@ public function resume();
278278
* source stream emits an `end` event. This can be disabled like this:
279279
*
280280
* ```php
281-
* $source->pipe($dest, array('end' => false));
281+
* $source->pipe($dest, ['end' => false]);
282282
* ```
283283
*
284284
* Note that this only applies to the `end` event.
@@ -322,7 +322,7 @@ public function resume();
322322
* @param array $options
323323
* @return WritableStreamInterface $dest stream as-is
324324
*/
325-
public function pipe(WritableStreamInterface $dest, array $options = array());
325+
public function pipe(WritableStreamInterface $dest, array $options = []);
326326

327327
/**
328328
* Closes the stream (forcefully).

‎src/ThroughStream.php

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -48,7 +48,7 @@
4848
* });
4949
* $through->on('data', $this->expectCallableOnceWith("[2, true]\n"));
5050
*
51-
* $through->write(array(2, true));
51+
* $through->write([2, true]);
5252
* ```
5353
*
5454
* The callback function is allowed to throw an `Exception`. In this case,
@@ -108,7 +108,7 @@ public function resume()
108108
}
109109
}
110110

111-
public function pipe(WritableStreamInterface $dest, array $options = array())
111+
public function pipe(WritableStreamInterface $dest, array $options = [])
112112
{
113113
return Util::pipe($this, $dest, $options);
114114
}
@@ -133,14 +133,14 @@ public function write($data)
133133
try {
134134
$data = \call_user_func($this->callback, $data);
135135
} catch (\Exception $e) {
136-
$this->emit('error', array($e));
136+
$this->emit('error', [$e]);
137137
$this->close();
138138

139139
return false;
140140
}
141141
}
142142

143-
$this->emit('data', array($data));
143+
$this->emit('data', [$data]);
144144

145145
// emit drain event on next resume if currently paused (throttled)
146146
if ($this->paused) {

‎src/Util.php

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -13,7 +13,7 @@ final class Util
1313
* @return WritableStreamInterface $dest stream as-is
1414
* @see ReadableStreamInterface::pipe() for more details
1515
*/
16-
public static function pipe(ReadableStreamInterface $source, WritableStreamInterface $dest, array $options = array())
16+
public static function pipe(ReadableStreamInterface $source, WritableStreamInterface $dest, array $options = [])
1717
{
1818
// source not readable => NO-OP
1919
if (!$source->isReadable()) {
@@ -27,7 +27,7 @@ public static function pipe(ReadableStreamInterface $source, WritableStreamInter
2727
return $dest;
2828
}
2929

30-
$dest->emit('pipe', array($source));
30+
$dest->emit('pipe', [$source]);
3131

3232
// forward all source data events as $dest->write()
3333
$source->on('data', $dataer = function ($data) use ($source, $dest) {

‎src/WritableResourceStream.php

Lines changed: 4 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -68,7 +68,9 @@ public function write($data)
6868
if (!$this->listening && $this->data !== '') {
6969
$this->listening = true;
7070

71-
$this->loop->addWriteStream($this->stream, array($this, 'handleWrite'));
71+
$this->loop->addWriteStream($this->stream, function () {
72+
$this->handleWrite();
73+
});
7274
}
7375

7476
return !isset($this->data[$this->softLimit - 1]);
@@ -112,7 +114,6 @@ public function close()
112114
}
113115
}
114116

115-
/** @internal */
116117
public function handleWrite()
117118
{
118119
$error = null;
@@ -137,7 +138,7 @@ public function handleWrite()
137138
// Should this turn out to be a permanent error later, it will eventually
138139
// send *nothing* and we can detect this.
139140
if (($sent === 0 || $sent === false) && $error !== null) {
140-
$this->emit('error', array(new \RuntimeException('Unable to write to stream: ' . $error)));
141+
$this->emit('error', [new \RuntimeException('Unable to write to stream: ' . $error)]);
141142
$this->close();
142143

143144
return;

‎tests/CompositeStreamTest.php

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -217,7 +217,7 @@ public function itShouldReceiveForwardedEvents()
217217
$composite->on('data', $this->expectCallableOnce());
218218
$composite->on('drain', $this->expectCallableOnce());
219219

220-
$readable->emit('data', array('foo'));
220+
$readable->emit('data', ['foo']);
221221
$writable->emit('drain');
222222
}
223223

@@ -241,7 +241,7 @@ public function itShouldHandlePipingCorrectly()
241241

242242
$input = new ThroughStream();
243243
$input->pipe($composite);
244-
$input->emit('data', array('foo'));
244+
$input->emit('data', ['foo']);
245245
}
246246

247247
/** @test */
@@ -262,6 +262,6 @@ public function itShouldForwardPipeCallsToReadableStream()
262262
->with('foo');
263263

264264
$composite->pipe($output);
265-
$readable->emit('data', array('foo'));
265+
$readable->emit('data', ['foo']);
266266
}
267267
}

‎tests/DuplexResourceStreamIntegrationTest.php

Lines changed: 4 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -373,7 +373,10 @@ public function testEmptyReadShouldntFcloseStream($condition, $loopFactory)
373373

374374
fwrite($client, "foobar\n");
375375

376-
$conn->handleData($stream);
376+
$ref = new \ReflectionMethod($conn, 'handleData');
377+
$ref->setAccessible(true);
378+
$ref->invoke($conn, 'handleData');
379+
377380

378381
fclose($stream);
379382
fclose($client);

0 commit comments

Comments
 (0)