Pool::__construct() - Code Metrics - Inspection of "Allow custom config to be passed to pool" - WyriHaximus/cakephp-async-orm - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( ba5abe...d52dbf )

by Cees-Jan

created 2016-04-11 15:32 UTC

Pool::__construct() A

↳ Parent: Pool

Complexity

Conditions	1
Paths	1

Size

Total Lines	14
Code Lines	9

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	11
CRAP Score	1

Importance

Changes	7
Bugs	1	Features	2

Metric	Value
c	7
b	1
f	2
dl	0
loc	14
ccs	11
cts	11
cp	1
rs	9.4285
cc	1
eloc	9
nc	1
nop	2
crap	1

<?php

namespace WyriHaximus\React\Cake\Orm;

use Cake\Core\Configure;
use React\ChildProcess\Process;
use React\EventLoop\LoopInterface;
use React\EventLoop\Timer\TimerInterface;
use React\Promise\Deferred;
use React\Promise\PromiseInterface;
use WyriHaximus\React\ChildProcess\Messenger\Messages\Factory;
use WyriHaximus\React\ChildProcess\Pool\Factory\Flexible;
use WyriHaximus\React\ChildProcess\Pool\Options;
use WyriHaximus\React\ChildProcess\Pool\PoolInfoInterface;
use WyriHaximus\React\ChildProcess\Pool\PoolInterface;
use WyriHaximus\React\ChildProcess\Pool\PoolUtilizerInterface;

/**
 * Class Pool
 * @package WyriHaximus\React\Cake\Orm
 */
class Pool implements PoolUtilizerInterface
{
    /**
     * @var LoopInterface
     */
    protected $loop;

    /**
     * @var PoolInfoInterface
     */
    protected $pool;

    /**
     * @var Pool
     */
    protected static $instance = null;

    /**
     * @var boolean
     */
    protected static $reset = false;

    /**
     * @param LoopInterface $loop
     * @param array $config
     */
    protected function __construct(LoopInterface $loop, array $config = [])
    {
        $this->loop = $loop;

        Flexible::create(
            new Process(
                Configure::read('WyriHaximus.React.Cake.Orm.Process')
            ),
            $this->loop,
            $this->applyConfig($config)
        )->then(function (PoolInterface $pool) {
            $this->pool = $pool;
        });
    }

    /**
     * @param array $config
     * @return array
     */
    protected function applyConfig(array $config)
    {
        if (!isset($config['processOptions'])) {
            $config['processOptions'] = Configure::read('WyriHaximus.React.Cake.Orm.Line');
        }

        if (!isset($config[Options::TTL])) {
            $config[Options::TTL] = Configure::read('WyriHaximus.React.Cake.Orm.TTL');
        }

        return $config;
    }

    /**
     * @param LoopInterface|null $loop
     * @param array $config
     * @return Pool
     * @throws \Exception
     */
    public static function getInstance(LoopInterface $loop = null, array $config = [])
    {
        if (null === self::$instance || self::$reset) {
            if (null === $loop) {
                throw new \Exception('Missing event loop');
            }
            self::$instance = new static($loop, $config);
            self::$reset = false;
        }

        return self::$instance;
    }

    public static function reset()
    {
        self::$reset = true;
    }

    /**
     * @param $tableName
     * @param $function
     * @param array $arguments
     * @return PromiseInterface
     */
    public function call($tableName, $function, array $arguments)
    {
        if ($this->pool instanceof PoolInterface) {
            return $this->poolCall($tableName, $function, $arguments);
        }

        return $this->waitForPoolCall($tableName, $function, $arguments);
    }

    /**
     * @param $tableName
     * @param $function
     * @param array $arguments
     * @return PromiseInterface
     */
    protected function poolCall($tableName, $function, array $arguments)
    {
        return $this->pool->rpc(Factory::rpc('table.call', [
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
            'function' => $function,
            'table' => $tableName,
            'arguments' => serialize($arguments),
        ]))->then(function ($result) {
            return \React\Promise\resolve($result['result']);
        });
    }

    /**
     * @param $tableName
     * @param $function
     * @param array $arguments
     * @return PromiseInterface
     */
    protected function waitForPoolCall($tableName, $function, array $arguments)
    {
        $deferred = new Deferred();

        $this->loop->addPeriodicTimer(
            0.1,
            function (TimerInterface $timer) use ($deferred, $tableName, $function, $arguments) {
                if ($this->pool instanceof PoolInterface) {
                    $timer->cancel();
                    $deferred->resolve($this->call($tableName, $function, $arguments));
                }
            }
        );

        return $deferred->promise();
    }

    /**
     * @inheritDoc
     */
    public function info()
    {
        if ($this->pool instanceof PoolInterface) {
            return $this->pool->info();
        }

        return [];
    }

    /**
     * @return LoopInterface
     */
    public function getLoop()
    {
        return $this->loop;
    }

    /**
     * @return PoolInfoInterface
     */
    public function getPool()
    {
        return $this->pool;
    }
}


1		<?php
2
3		namespace WyriHaximus\React\Cake\Orm;
4
5		use Cake\Core\Configure;
6		use React\ChildProcess\Process;
7		use React\EventLoop\LoopInterface;
8		use React\EventLoop\Timer\TimerInterface;
9		use React\Promise\Deferred;
10		use React\Promise\PromiseInterface;
11		use WyriHaximus\React\ChildProcess\Messenger\Messages\Factory;
12		use WyriHaximus\React\ChildProcess\Pool\Factory\Flexible;
13		use WyriHaximus\React\ChildProcess\Pool\Options;
14		use WyriHaximus\React\ChildProcess\Pool\PoolInfoInterface;
15		use WyriHaximus\React\ChildProcess\Pool\PoolInterface;
16		use WyriHaximus\React\ChildProcess\Pool\PoolUtilizerInterface;
17
18		/**
19		* Class Pool
20		* @package WyriHaximus\React\Cake\Orm
21		*/
22		class Pool implements PoolUtilizerInterface
23		{
24		/**
25		* @var LoopInterface
26		*/
27		protected $loop;
28
29		/**
30		* @var PoolInfoInterface
31		*/
32		protected $pool;
33
34		/**
35		* @var Pool
36		*/
37		protected static $instance = null;
38
39		/**
40		* @var boolean
41		*/
42		protected static $reset = false;
43
44		/**
45		* @param LoopInterface $loop
46		* @param array $config
47		*/
48	6	protected function __construct(LoopInterface $loop, array $config = [])
49		{
50	6	$this->loop = $loop;
51
52	6	Flexible::create(
53	6	new Process(
54	6	Configure::read('WyriHaximus.React.Cake.Orm.Process')
55	6	),
56	6	$this->loop,
57	6	$this->applyConfig($config)
58		)->then(function (PoolInterface $pool) {
59	6	$this->pool = $pool;
60	6	});
61	6	}
62
63		/**
64		* @param array $config
65		* @return array
66		*/
67	6	protected function applyConfig(array $config)
68		{
69	6	if (!isset($config['processOptions'])) {
70	6	$config['processOptions'] = Configure::read('WyriHaximus.React.Cake.Orm.Line');
71	6	}
72
73	6	if (!isset($config[Options::TTL])) {
74	6	$config[Options::TTL] = Configure::read('WyriHaximus.React.Cake.Orm.TTL');
75	6	}
76
77	6	return $config;
78		}
79
80		/**
81		* @param LoopInterface\|null $loop
82		* @param array $config
83		* @return Pool
84		* @throws \Exception
85		*/
86	6	public static function getInstance(LoopInterface $loop = null, array $config = [])
87		{
88	6	if (null === self::$instance \|\| self::$reset) {
89	6	if (null === $loop) {
90		throw new \Exception('Missing event loop');
91		}
92	6	self::$instance = new static($loop, $config);
93	6	self::$reset = false;
94	6	}
95
96	6	return self::$instance;
97		}
98
99	23	public static function reset()
100		{
101	23	self::$reset = true;
102	23	}
103
104		/**
105		* @param $tableName
106		* @param $function
107		* @param array $arguments
108		* @return PromiseInterface
109		*/
110		public function call($tableName, $function, array $arguments)
111		{
112		if ($this->pool instanceof PoolInterface) {
113		return $this->poolCall($tableName, $function, $arguments);
114		}
115
116		return $this->waitForPoolCall($tableName, $function, $arguments);
117		}
118
119		/**
120		* @param $tableName
121		* @param $function
122		* @param array $arguments
123		* @return PromiseInterface
124		*/
125		protected function poolCall($tableName, $function, array $arguments)
126		{
127		return $this->pool->rpc(Factory::rpc('table.call', [
		0 ignored issues – show Bug introduced 2016-03-02 20:10 UTC by Report Bug Copy Issue Report It seems like you code against a concrete implementation and not the interface `WyriHaximus\React\ChildP...\Pool\PoolInfoInterface` as the method `rpc()` does only exist in the following implementations of said interface: `WyriHaximus\React\ChildProcess\Pool\Pool\Dummy`, `WyriHaximus\React\ChildProcess\Pool\Pool\Fixed`, `WyriHaximus\React\ChildProcess\Pool\Pool\Flexible`. Let’s take a look at an example: interface User { /** @return string / public function getPassword(); } class MyUser implements User { public function getPassword() { // return something } public function getDisplayName() { // return some name. } } class AuthSystem { public function authenticate(User $user) { $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName())); // do something. } } In the above example, the authenticate() method works fine as long as you just pass instances of MyUser. However, if you now also want to pass a different implementation of User which does not have a getDisplayName() method, the code will break. Available Fixes Change the type-hint for the parameter: class AuthSystem { public function authenticate(MyUser $user) { / ... / } } Add an additional type-check: class AuthSystem { public function authenticate(User $user) { if ($user instanceof MyUser) { $this->logger->info(/* ... /); } // or alternatively if ( ! $user instanceof MyUser) { throw new \LogicException( '$user must be an instance of MyUser, ' .'other instances are not supported.' ); } } } Note:* PHP Analyzer uses reverse abstract interpretation to narrow down the types inside the if block in such a case. Add the method to the interface: interface User { /** @return string / public function getPassword(); /* @return string */ public function getDisplayName(); } Loading history...
128		'function' => $function,
129		'table' => $tableName,
130		'arguments' => serialize($arguments),
131		]))->then(function ($result) {
132		return \React\Promise\resolve($result['result']);
133		});
134		}
135
136		/**
137		* @param $tableName
138		* @param $function
139		* @param array $arguments
140		* @return PromiseInterface
141		*/
142		protected function waitForPoolCall($tableName, $function, array $arguments)
143		{
144		$deferred = new Deferred();
145
146		$this->loop->addPeriodicTimer(
147		0.1,
148		function (TimerInterface $timer) use ($deferred, $tableName, $function, $arguments) {
149		if ($this->pool instanceof PoolInterface) {
150		$timer->cancel();
151		$deferred->resolve($this->call($tableName, $function, $arguments));
152		}
153		}
154		);
155
156		return $deferred->promise();
157		}
158
159		/**
160		* @inheritDoc
161		*/
162	1	public function info()
163		{
164	1	if ($this->pool instanceof PoolInterface) {
165	1	return $this->pool->info();
166		}
167
168		return [];
169		}
170
171		/**
172		* @return LoopInterface
173		*/
174	1	public function getLoop()
175		{
176	1	return $this->loop;
177		}
178
179		/**
180		* @return PoolInfoInterface
181		*/
182	1	public function getPool()
183		{
184	1	return $this->pool;
185		}
186		}
187

WyriHaximus / cakephp-async-orm

Push — master ( ba5abe...d52dbf )

Pool::__construct() A

Complexity

Size

Duplication

Code Coverage

Importance

Available Fixes

Duplication Side-by-Side

Filter issues like