ParallelProcess::getErrorOutput() - Code Metrics - Inspection of "Symfony process" - spatie/async - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#5)

by Brent

created 2017-12-24 11:23 UTC

ParallelProcess::getErrorOutput() A

↳ Parent: ParallelProcess

Complexity

Conditions	3
Paths	3

Size

Total Lines	14
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	3
eloc	7
nc	3
nop	0
dl	0
loc	14
rs	9.4285
c	0
b	0
f	0

<?php

namespace Spatie\Async;

use Throwable;
use Symfony\Component\Process\Process;
use Spatie\Async\Output\SerializableException;

class ParallelProcess
{
    protected $process;
    protected $id;
    protected $pid;

    protected $successCallbacks = [];
    protected $errorCallbacks = [];
    protected $timeoutCallbacks = [];

    protected $output;
    protected $errorOutput;

    protected $startTime;

    public function __construct(Process $process)
    {
        $this->process = $process;
        $this->id = uniqid(getmypid());
    }

    public static function create(Process $process): self
    {
        return new self($process);
    }

    public function then(callable $callback): self
    {
        $this->successCallbacks[] = $callback;

        return $this;
    }

    public function catch(callable $callback): self

    {
        $this->errorCallbacks[] = $callback;

        return $this;
class A {
    var $property;
}
    }

    public function timeout(callable $callback): self
    {
        $this->timeoutCallbacks[] = $callback;

        return $this;
    }

    public function start(): self
    {
        $this->startTime = microtime(true);

        $this->process->start();

        $this->pid = $this->process->getPid();

        return $this;
    }

    public function stop(): self
    {
        $this->process->stop(10, SIGKILL);

        return $this;
    }

    public function isRunning(): bool
    {
        return $this->process->isRunning();
    }

    public function isSuccessful(): bool
    {
        return $this->process->isSuccessful();
    }

    public function isTerminated(): bool
    {
        return $this->process->isTerminated();
    }

    public function getOutput()
    {
        if (! $this->output) {
            $processOutput = $this->process->getOutput();

            $this->output = @unserialize(base64_decode($processOutput));

            if (! $this->output) {
                $this->errorOutput = $processOutput;
            }
        }

        return $this->output;
    }

    public function getErrorOutput()
    {
        if (! $this->errorOutput) {
            $processOutput = $this->process->getErrorOutput();

            $this->errorOutput = @unserialize(base64_decode($processOutput));

            if (! $this->errorOutput) {
                $this->errorOutput = $processOutput;
            }
        }

        return $this->errorOutput;
    }

    public function getProcess(): Process
    {
        return $this->process;
    }

    public function getId(): string
    {
        return $this->id;
    }

    public function getPid(): ?string
    {
        return $this->pid;
    }

    public function getCurrentExecutionTime(): float
    {
        return microtime(true) - $this->startTime;
    }

    public function triggerSuccess()
    {
        if ($this->getErrorOutput()) {
            $this->triggerError();

            return;
        }

        $output = $this->getOutput();

        foreach ($this->successCallbacks as $callback) {
            call_user_func_array($callback, [$output]);
        }

        return $output;
    }

    public function triggerError()
    {
        $exception = $this->getErrorOutput();

        if ($exception instanceof SerializableException) {
            $exception = $exception->asThrowable();
        }

        foreach ($this->errorCallbacks as $callback) {
            call_user_func_array($callback, [$exception]);
        }

        if (! $this->errorCallbacks) {

            if ($exception instanceof Throwable) {
                throw $exception;
            }

            throw ParallelError::fromException($exception);
        }
    }

    public function triggerTimeout()
    {
        foreach ($this->timeoutCallbacks as $callback) {
            call_user_func_array($callback, []);
        }
    }
}


1			<?php
2
3			namespace Spatie\Async;
4
5			use Throwable;
6			use Symfony\Component\Process\Process;
7			use Spatie\Async\Output\SerializableException;
8
9			class ParallelProcess
10			{
11			protected $process;
12			protected $id;
13			protected $pid;
14
15			protected $successCallbacks = [];
16			protected $errorCallbacks = [];
17			protected $timeoutCallbacks = [];
18
19			protected $output;
20			protected $errorOutput;
21
22			protected $startTime;
23
24			public function __construct(Process $process)
25			{
26			$this->process = $process;
27			$this->id = uniqid(getmypid());
28			}
29
30			public static function create(Process $process): self
31			{
32			return new self($process);
33			}
34
35			public function then(callable $callback): self
36			{
37			$this->successCallbacks[] = $callback;
38
39			return $this;
40			}
41
42			public function catch(callable $callback): self
			0 ignored issues – show Coding Style introduced 2017-12-14 10:27 UTC by Report Bug Copy Issue Report Possible parse error: non-abstract method defined as abstract Loading history... Coding Style introduced 2017-12-14 10:27 UTC by Report Bug Copy Issue Report It is generally advisable to only define one property per statement. Only declaring a single property per statement allows you to later on add doc comments more easily. It is also recommended by PSR2, so it is a common style that many people expect. Loading history...
43			{
44			$this->errorCallbacks[] = $callback;
45
46			return $this;
			0 ignored issues – show Coding Style introduced 2017-12-14 10:27 UTC by Report Bug Copy Issue Report The visibility should be declared for property `$this`. The PSR-2 coding standard requires that all properties in a class have their visibility explicitly declared. If you declare a property using class A { var $property; } the property is implicitly global. To learn more about the PSR-2, please see the PHP-FIG site on the PSR-2. Loading history...
47			}
48
49			public function timeout(callable $callback): self
50			{
51			$this->timeoutCallbacks[] = $callback;
52
53			return $this;
54			}
55
56			public function start(): self
57			{
58			$this->startTime = microtime(true);
59
60			$this->process->start();
61
62			$this->pid = $this->process->getPid();
63
64			return $this;
65			}
66
67			public function stop(): self
68			{
69			$this->process->stop(10, SIGKILL);
70
71			return $this;
72			}
73
74			public function isRunning(): bool
75			{
76			return $this->process->isRunning();
77			}
78
79			public function isSuccessful(): bool
80			{
81			return $this->process->isSuccessful();
82			}
83
84			public function isTerminated(): bool
85			{
86			return $this->process->isTerminated();
87			}
88
89			public function getOutput()
90			{
91			if (! $this->output) {
92			$processOutput = $this->process->getOutput();
93
94			$this->output = @unserialize(base64_decode($processOutput));
95
96			if (! $this->output) {
97			$this->errorOutput = $processOutput;
98			}
99			}
100
101			return $this->output;
102			}
103
104			public function getErrorOutput()
105			{
106			if (! $this->errorOutput) {
107			$processOutput = $this->process->getErrorOutput();
108
109			$this->errorOutput = @unserialize(base64_decode($processOutput));
110
111			if (! $this->errorOutput) {
112			$this->errorOutput = $processOutput;
113			}
114			}
115
116			return $this->errorOutput;
117			}
118
119			public function getProcess(): Process
120			{
121			return $this->process;
122			}
123
124			public function getId(): string
125			{
126			return $this->id;
127			}
128
129			public function getPid(): ?string
130			{
131			return $this->pid;
132			}
133
134			public function getCurrentExecutionTime(): float
135			{
136			return microtime(true) - $this->startTime;
137			}
138
139			public function triggerSuccess()
140			{
141			if ($this->getErrorOutput()) {
142			$this->triggerError();
143
144			return;
145			}
146
147			$output = $this->getOutput();
148
149			foreach ($this->successCallbacks as $callback) {
150			call_user_func_array($callback, [$output]);
151			}
152
153			return $output;
154			}
155
156			public function triggerError()
157			{
158			$exception = $this->getErrorOutput();
159
160			if ($exception instanceof SerializableException) {
161			$exception = $exception->asThrowable();
162			}
163
164			foreach ($this->errorCallbacks as $callback) {
165			call_user_func_array($callback, [$exception]);
166			}
167
168			if (! $this->errorCallbacks) {
			0 ignored issues – show Bug Best Practice introduced 2017-12-22 15:16 UTC by Report Bug Copy Issue Report The expression `$this->errorCallbacks` of type `array` is implicitly converted to a boolean; are you sure this is intended? If so, consider using `empty($expr)` instead to make it clear that you intend to check for an array without elements. This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history...
169			if ($exception instanceof Throwable) {
170			throw $exception;
171			}
172
173			throw ParallelError::fromException($exception);
174			}
175			}
176
177			public function triggerTimeout()
178			{
179			foreach ($this->timeoutCallbacks as $callback) {
180			call_user_func_array($callback, []);
181			}
182			}
183			}
184

spatie / async

GitHub Access Token became invalid

Pull Request — master (#5)

ParallelProcess::getErrorOutput() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like