PromiseCommand::hasFinished() - Code Metrics - Inspection of "Fix rule" - PlasmaPHP/driver-mysql - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( f731b0...b5a8f2 )

by Charlotte

created 2019-01-17 20:06 UTC

PromiseCommand::hasFinished() A

↳ Parent: PromiseCommand

Complexity

Conditions	1
Paths	1

Size

Total Lines	2
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes

Metric	Value
cc	1
eloc	1
nc	1
nop	0
dl	0
loc	2
ccs	2
cts	2
cp	1
crap	1
rs	10
c	0
b	0
f	0

<?php
/**
 * Plasma Driver MySQL component
 * Copyright 2018-2019 PlasmaPHP, All Rights Reserved
 *
 * Website: https://github.com/PlasmaPHP
 * License: https://github.com/PlasmaPHP/driver-mysql/blob/master/LICENSE
*/

namespace Plasma\Drivers\MySQL\Commands;

/**
 * Abstract command which has a promise.
 * @internal
 */
abstract class PromiseCommand implements CommandInterface {
    use \Evenement\EventEmitterTrait;
    
    /**
     * @var \Plasma\DriverInterface
     */
    protected $driver;
    
    /**
     * @var \React\Promise\Deferred
     */
    protected $deferred;
    
    /**
     * @var mixed
     */
    protected $resolveValue;
    
    /**
     * @var bool
     */
    protected $finished = false;
    
    /**
     * @var int|null
     */
    protected $fieldsCount;
    
    /**
     * Constructor.
     * @param \Plasma\DriverInterface  $driver
     */
    function __construct(\Plasma\DriverInterface $driver) {
        $this->driver = $driver;
        $this->deferred = new \React\Promise\Deferred();
        
        $this->once('error', function (\Throwable $error) {
            $this->deferred->reject($error);
        });
        
        $this->once('end', function () {
            // Let the event loop read the stream buffer before resolving
            $this->driver->getLoop()->futureTick(function () {
                $this->deferred->resolve($this->resolveValue);
                $this->resolveValue = null;
            });
        });
    }
    
    /**
     * Get the encoded message for writing to the database connection.
     * @return string
     */
    abstract function getEncodedMessage(): string;
    
    /**
     * Get the promise.
     * @return \React\Promise\PromiseInterface
     */
    function getPromise(): \React\Promise\PromiseInterface {
        return $this->deferred->promise();
    }
    
    /**
     * Sets the parser state, if necessary. If not, return `-1`.
     * @return int
     */
    function setParserState(): int {
        return -1;
    }
    
    /**
     * Sets the command as completed. This state gets reported back to the user.
     * @return void
     */
    function onComplete(): void {
        $this->finished = true;
        $this->emit('end');
    }
    
    /**
     * Sets the command as errored. This state gets reported back to the user.
     * @param \Throwable  $throwable
     * @return void
     */
    function onError(\Throwable $throwable): void {
        $this->finished = true;
        
        if($this->resolveValue !== null) {
            // Let the event loop read the stream buffer and resolve the promise before emitting
            // Works around a race condition, where the promise resolves
            // after receiving an error response packet
            // and therefore the user misses the error event
            $this->driver->getLoop()->futureTick(function () use (&$throwable) {
                $this->emit('error', array($throwable));
            });
            
            return;
        }
        
        $this->emit('error', array($throwable));
    }
    
    /**
     * Sends the next received value into the command.
     * @param mixed  $value
     * @return void
     */
    abstract function onNext($value): void;
    
    /**
     * Whether the command has finished.
     * @return bool
     */
    function hasFinished(): bool {
        return $this->finished;
    }
    
    /**
     * Whether this command sets the connection as busy.
     * @return bool
     */
    function waitForCompletion(): bool {
        return true;
    }
    
    /**
     * Whether the sequence ID should be resetted.
     * @return bool
     */
    abstract function resetSequence(): bool;
    
    /**
     * Handles the column definitions of query commands on next caller.
     * @param \Plasma\BinaryBuffer                  $buffer
     * @param \Plasma\Drivers\MySQL\ProtocolParser  $parser
     * @return \Plasma\ColumnDefinitionInterface|null
     */
    function handleQueryOnNextCallerColumns(\Plasma\BinaryBuffer $buffer, \Plasma\Drivers\MySQL\ProtocolParser $parser): ?\Plasma\ColumnDefinitionInterface {
        if($this->fieldsCount === null) {
            $fieldCount = $buffer->readIntLength();
            
            if($fieldCount === 0x00) {
                $this->driver->getLoop()->futureTick(function () use (&$buffer, &$parser) {
                    $msg = new \Plasma\Drivers\MySQL\Messages\OkResponseMessage($parser);
                    $parser->handleMessage($buffer, $msg);
                });
                
                return null;
            } elseif($fieldCount === 0xFB) {
                // Handle it on future tick, so we can cleanly finish the buffer of this call
                $this->driver->getLoop()->futureTick(function () use (&$buffer, &$parser) {
                    $msg = new \Plasma\Drivers\MySQL\Messages\LocalInFileRequestMessage($parser);
                    $parser->handleMessage($buffer, $msg);
                });
                
                return null;
            } elseif($fieldCount === 0xFF) {
                $this->driver->getLoop()->futureTick(function () use (&$buffer, &$parser) {
                    $msg = new \Plasma\Drivers\MySQL\Messages\ErrResponseMessage($parser);
                    $parser->handleMessage($buffer, $msg);
                });
                
                return null;
            }
            
            $this->fieldsCount = $fieldCount;
            return null;
        }
        
        return static::parseColumnDefinition($buffer);
    }
    
    /**
     * Parses the column definition.
     * @param \Plasma\BinaryBuffer  $buffer
     * @return \Plasma\ColumnDefinitionInterface
     */
    static function parseColumnDefinition(\Plasma\BinaryBuffer $buffer): \Plasma\ColumnDefinitionInterface {
        $buffer->readStringLength(); // catalog - always "def"
        $database = $buffer->readStringLength();
        
        $table = $buffer->readStringLength();
        $buffer->readStringLength(); // orgTable
        
        $name = $buffer->readStringLength();
        $buffer->readStringLength(); // orgName
        
        $buffer->read(1); // 0x0C
        
        $charset = $buffer->readInt2();
        $length = $buffer->readInt4();
        $type = $buffer->readInt1();
        $flags = $buffer->readInt2();
        $decimals = $buffer->readInt1();
        
        $buffer->read(2); // fillers
        
        /*if($this instanceof COM_FIELD_LIST) {
            $buffer->readStringLength();
        }*/
        
        $charset = \Plasma\Drivers\MySQL\CharacterSetFlags::CHARSET_MAP[$charset] ?? 'Unknown charset "'.$charset.'"';
        $type = \Plasma\Drivers\MySQL\FieldFlags::TYPE_MAP[$type] ?? 'Unknown type "'.$type.'"';
        $nullable = (($flags & \Plasma\Drivers\MySQL\FieldFlags::NOT_NULL_FLAG) === 0);
        
        return (new \Plasma\ColumnDefinition($database, $table, $name, $type, $charset, $length, $nullable, $flags, $decimals));
    }
    
    /**
     * Parses the text resultset row and returns the row.
     * @param \Plasma\BinaryBuffer  $buffer
     * @return array
     */
    protected function parseResultsetRow(\Plasma\BinaryBuffer $buffer): array {
        $row = array();
        
        /** @var \Plasma\ColumnDefinitionInterface  $column */
        foreach($this->fields as $column) {
            $rawValue = $buffer->readStringLength();
            
            try {
                $value = \Plasma\Types\TypeExtensionsManager::getManager('driver-mysql')
                    ->decodeType($column->getType(), $rawValue)
                    ->getValue();
            } catch (\Plasma\Exception $e) {
                $value = \Plasma\Drivers\MySQL\TextProtocolValues::decode($column, $rawValue);
            }
            
            $row[$column->getName()] = $value;
        }
        
        return $row;
    }
}


1		<?php
2		/**
3		* Plasma Driver MySQL component
4		* Copyright 2018-2019 PlasmaPHP, All Rights Reserved
5		*
6		* Website: https://github.com/PlasmaPHP
7		* License: https://github.com/PlasmaPHP/driver-mysql/blob/master/LICENSE
8		*/
9
10		namespace Plasma\Drivers\MySQL\Commands;
11
12		/**
13		* Abstract command which has a promise.
14		* @internal
15		*/
16		abstract class PromiseCommand implements CommandInterface {
17		use \Evenement\EventEmitterTrait;
18
19		/**
20		* @var \Plasma\DriverInterface
21		*/
22		protected $driver;
23
24		/**
25		* @var \React\Promise\Deferred
26		*/
27		protected $deferred;
28
29		/**
30		* @var mixed
31		*/
32		protected $resolveValue;
33
34		/**
35		* @var bool
36		*/
37		protected $finished = false;
38
39		/**
40		* @var int\|null
41		*/
42		protected $fieldsCount;
43
44		/**
45		* Constructor.
46		* @param \Plasma\DriverInterface $driver
47		*/
48	65	function __construct(\Plasma\DriverInterface $driver) {
49	65	$this->driver = $driver;
50	65	$this->deferred = new \React\Promise\Deferred();
51
52		$this->once('error', function (\Throwable $error) {
53		$this->deferred->reject($error);
54	65	});
55
56		$this->once('end', function () {
57		// Let the event loop read the stream buffer before resolving
58		$this->driver->getLoop()->futureTick(function () {
59	56	$this->deferred->resolve($this->resolveValue);
60	56	$this->resolveValue = null;
61	56	});
62	65	});
63	65	}
64
65		/**
66		* Get the encoded message for writing to the database connection.
67		* @return string
68		*/
69		abstract function getEncodedMessage(): string;
70
71		/**
72		* Get the promise.
73		* @return \React\Promise\PromiseInterface
74		*/
75	65	function getPromise(): \React\Promise\PromiseInterface {
76	65	return $this->deferred->promise();
77		}
78
79		/**
80		* Sets the parser state, if necessary. If not, return `-1`.
81		* @return int
82		*/
83	56	function setParserState(): int {
84	56	return -1;
85		}
86
87		/**
88		* Sets the command as completed. This state gets reported back to the user.
89		* @return void
90		*/
91	56	function onComplete(): void {
92	56	$this->finished = true;
93	56	$this->emit('end');
94	56	}
95
96		/**
97		* Sets the command as errored. This state gets reported back to the user.
98		* @param \Throwable $throwable
99		* @return void
100		*/
101		function onError(\Throwable $throwable): void {
102		$this->finished = true;
103
104		if($this->resolveValue !== null) {
105		// Let the event loop read the stream buffer and resolve the promise before emitting
106		// Works around a race condition, where the promise resolves
107		// after receiving an error response packet
108		// and therefore the user misses the error event
109		$this->driver->getLoop()->futureTick(function () use (&$throwable) {
110		$this->emit('error', array($throwable));
111		});
112
113		return;
114		}
115
116		$this->emit('error', array($throwable));
117		}
118
119		/**
120		* Sends the next received value into the command.
121		* @param mixed $value
122		* @return void
123		*/
124		abstract function onNext($value): void;
125
126		/**
127		* Whether the command has finished.
128		* @return bool
129		*/
130	56	function hasFinished(): bool {
131	56	return $this->finished;
132		}
133
134		/**
135		* Whether this command sets the connection as busy.
136		* @return bool
137		*/
138	56	function waitForCompletion(): bool {
139	56	return true;
140		}
141
142		/**
143		* Whether the sequence ID should be resetted.
144		* @return bool
145		*/
146		abstract function resetSequence(): bool;
147
148		/**
149		* Handles the column definitions of query commands on next caller.
150		* @param \Plasma\BinaryBuffer $buffer
151		* @param \Plasma\Drivers\MySQL\ProtocolParser $parser
152		* @return \Plasma\ColumnDefinitionInterface\|null
153		*/
154	46	function handleQueryOnNextCallerColumns(\Plasma\BinaryBuffer $buffer, \Plasma\Drivers\MySQL\ProtocolParser $parser): ?\Plasma\ColumnDefinitionInterface {
155	46	if($this->fieldsCount === null) {
156	45	$fieldCount = $buffer->readIntLength();
157
158	45	if($fieldCount === 0x00) {
159		$this->driver->getLoop()->futureTick(function () use (&$buffer, &$parser) {
160		$msg = new \Plasma\Drivers\MySQL\Messages\OkResponseMessage($parser);
161		$parser->handleMessage($buffer, $msg);
162		});
163
164		return null;
165	45	} elseif($fieldCount === 0xFB) {
166		// Handle it on future tick, so we can cleanly finish the buffer of this call
167		$this->driver->getLoop()->futureTick(function () use (&$buffer, &$parser) {
168		$msg = new \Plasma\Drivers\MySQL\Messages\LocalInFileRequestMessage($parser);
169		$parser->handleMessage($buffer, $msg);
170		});
171
172		return null;
173	45	} elseif($fieldCount === 0xFF) {
174		$this->driver->getLoop()->futureTick(function () use (&$buffer, &$parser) {
175		$msg = new \Plasma\Drivers\MySQL\Messages\ErrResponseMessage($parser);
176		$parser->handleMessage($buffer, $msg);
177		});
178
179		return null;
180		}
181
182	45	$this->fieldsCount = $fieldCount;
183	45	return null;
184		}
185
186	46	return static::parseColumnDefinition($buffer);
187		}
188
189		/**
190		* Parses the column definition.
191		* @param \Plasma\BinaryBuffer $buffer
192		* @return \Plasma\ColumnDefinitionInterface
193		*/
194	46	static function parseColumnDefinition(\Plasma\BinaryBuffer $buffer): \Plasma\ColumnDefinitionInterface {
195	46	$buffer->readStringLength(); // catalog - always "def"
196	46	$database = $buffer->readStringLength();
197
198	46	$table = $buffer->readStringLength();
199	46	$buffer->readStringLength(); // orgTable
200
201	46	$name = $buffer->readStringLength();
202	46	$buffer->readStringLength(); // orgName
203
204	46	$buffer->read(1); // 0x0C
205
206	46	$charset = $buffer->readInt2();
207	46	$length = $buffer->readInt4();
208	46	$type = $buffer->readInt1();
209	46	$flags = $buffer->readInt2();
210	46	$decimals = $buffer->readInt1();
211
212	46	$buffer->read(2); // fillers
213
214		/*if($this instanceof COM_FIELD_LIST) {
215		$buffer->readStringLength();
216		}*/
217
218	46	$charset = \Plasma\Drivers\MySQL\CharacterSetFlags::CHARSET_MAP[$charset] ?? 'Unknown charset "'.$charset.'"';
219	46	$type = \Plasma\Drivers\MySQL\FieldFlags::TYPE_MAP[$type] ?? 'Unknown type "'.$type.'"';
220	46	$nullable = (($flags & \Plasma\Drivers\MySQL\FieldFlags::NOT_NULL_FLAG) === 0);
221
222	46	return (new \Plasma\ColumnDefinition($database, $table, $name, $type, $charset, $length, $nullable, $flags, $decimals));
223		}
224
225		/**
226		* Parses the text resultset row and returns the row.
227		* @param \Plasma\BinaryBuffer $buffer
228		* @return array
229		*/
230	10	protected function parseResultsetRow(\Plasma\BinaryBuffer $buffer): array {
231	10	$row = array();
232
233		/** @var \Plasma\ColumnDefinitionInterface $column */
234	10	foreach($this->fields as $column) {
235	10	$rawValue = $buffer->readStringLength();
236
237		try {
238	10	$value = \Plasma\Types\TypeExtensionsManager::getManager('driver-mysql')
239	10	->decodeType($column->getType(), $rawValue)
240		->getValue();
241	10	} catch (\Plasma\Exception $e) {
242	10	$value = \Plasma\Drivers\MySQL\TextProtocolValues::decode($column, $rawValue);
243		}
244
245	10	$row[$column->getName()] = $value;
246		}
247
248	10	return $row;
249		}
250		}
251

PlasmaPHP / driver-mysql

GitHub Access Token became invalid

Push — master ( f731b0...b5a8f2 )

PromiseCommand::hasFinished() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like