JobClass - Code Metrics - Inspection of "Define job callable name per Annotation (see https..." - mikaelkael/GearmanBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 079541...355f41 )

by Mickael

created 2016-11-13 19:45 UTC

JobClass A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	270
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

94.83%

Importance

Changes

Metric	Value
wmc	19
lcom	1
cbo	1
dl	0
loc	270
c	0
b	0
f	0
ccs	55
cts	58
cp	0.9483
rs	10

8 Methods

Rating	Name	Size	Complexity
B	__construct()	33	5
A	loadServers()	15	4
A	loadIterations()	6	2
A	loadDefaultMethod()	6	2
A	loadMinimumExecutionTime()	6	2
A	loadTimeout()	6	2
A	toArray()	17	1
A	setContainer()	4	1

<?php

/**
 * Gearman Bundle for Symfony2
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Feel free to edit as you please, and have fun.
 *
 * @author Marc Morera <[email protected]>
 */

namespace Mmoreram\GearmanBundle\Module;

use ReflectionMethod;
use Symfony\Component\DependencyInjection\ContainerAwareInterface;
use Symfony\Component\DependencyInjection\ContainerInterface;

use Mmoreram\GearmanBundle\Driver\Gearman\Job as JobAnnotation;

/**
 * Job class
 *
 * This class provide all worker definition.
 *
 * @since 2.3.1
 */
class JobClass implements ContainerAwareInterface
{
    /**
     * @var string
     *
     * Default description when is not defined
     */
    const DEFAULT_DESCRIPTION = 'No description is defined';

    /**
     * @var string
     *
     * Callable name for this job
     * If is setted on annotations, this value will be used
     *  otherwise, natural method name will be used.
     */
    private $callableName;

    /**
     * @var string
     *
     * Method name
     */
    private $methodName;

    /**
     * @var string
     *
     * RealCallable name for this job without the job prefix
     *
     */
    private $realCallableNameNoPrefix;

    /**
     * @var string
     *
     * RealCallable name for this job
     * natural method name will be used.
     */
    private $realCallableName;

    /**
     * @var string
     *
     * Description of Job
     */
    private $description;

    /**
     * @var integer
     *
     * Number of iterations this job will be alive before die
     */
    private $iterations;

    /**
     * @var string
     *
     * Default method this job will be call into Gearman client
     */
    private $defaultMethod;

    /**
     * @var int
     *
     * Job minimum execution time
     */
    private $minimumExecutionTime;

    /**
     * @var int
     *
     * Timeout for idle worker
     */
    private $timeout;

    /**
     * @var array
     *
     * Collection of servers to connect
     */
    private $servers;

    /**
     * @var string
     *
     * The prefix to be prepended to all job callable names.
     */
    private $jobPrefix;

    /**
     * @var ContainerInterface
     */
    protected $container;

    /**
     * Construct method
     *
     * @param JobAnnotation    $jobAnnotation     JobAnnotation class
     * @param ReflectionMethod $reflectionMethod  ReflextionMethod class
     * @param string           $callableNameClass Callable name class
     * @param array            $servers           Array of servers defined for Worker
     * @param array            $defaultSettings   Default settings for Worker
     */
    public function __construct(
        JobAnnotation $jobAnnotation,
        ReflectionMethod $reflectionMethod,
        $callableNameClass,
        array $servers,
        array $defaultSettings
    )
    {

        $this->callableName = is_null($jobAnnotation->name)
            ? $reflectionMethod->getName()
            : $jobAnnotation->name;

        $this->methodName = $reflectionMethod->getName();
$a = "a";
$ab = "ab";
$abc = "abc";
        $this->realCallableNameNoPrefix = is_null($jobAnnotation->realCallableName)
            ? str_replace('\\', '', $callableNameClass . '~' . $this->callableName)
            : $jobAnnotation->realCallableName;

        $this->jobPrefix = isset($defaultSettings['jobPrefix'])
            ? $defaultSettings['jobPrefix']
            : null;

        $this->realCallableName = $this->jobPrefix . $this->realCallableNameNoPrefix;
        $this->description = is_null($jobAnnotation->description)
$a = "a";
$ab = "ab";
$abc = "abc";
            ? self::DEFAULT_DESCRIPTION
            : $jobAnnotation->description;

        $this->servers = $this->loadServers($jobAnnotation, $servers);
$a = "a";
$ab = "ab";
$abc = "abc";
        $this->iterations = $this->loadIterations($jobAnnotation, $defaultSettings);
$a = "a";
$ab = "ab";
$abc = "abc";
        $this->minimumExecutionTime = $this->loadMinimumExecutionTime($jobAnnotation, $defaultSettings);
        $this->timeout = $this->loadTimeout($jobAnnotation, $defaultSettings);
$a = "a";
$ab = "ab";
$abc = "abc";
        $this->defaultMethod = $this->loadDefaultMethod($jobAnnotation, $defaultSettings);
$a = "a";
$ab = "ab";
$abc = "abc";
    }

    /**
     * Load servers
     *
     * If any server is defined in JobAnnotation, this one is used.
     * Otherwise is used servers set in Class
     *
     * @param JobAnnotation $jobAnnotation JobAnnotation class
     * @param array         $servers       Array of servers defined for Worker
     *
     * @return array Servers
     */
    private function loadServers(JobAnnotation $jobAnnotation, array $servers)
    {

        /**
         * If is configured some servers definition in the worker, overwrites
         */
        if ($jobAnnotation->servers) {

            $servers = (is_array($jobAnnotation->servers) && !isset($jobAnnotation->servers['host']))

                ? $jobAnnotation->servers
                : array($jobAnnotation->servers);
        }

        return $servers;
    }

    /**
     * Load iterations
     *
     * If iterations is defined in JobAnnotation, this one is used.
     * Otherwise is used set in Class
     *
     * @param JobAnnotation $jobAnnotation   JobAnnotation class
     * @param array         $defaultSettings Default settings for Worker
     *
     * @return integer Iteration
     */
    private function loadIterations(JobAnnotation $jobAnnotation, array $defaultSettings)
    {
        return is_null($jobAnnotation->iterations)
            ? (int) $defaultSettings['iterations']
            : (int) $jobAnnotation->iterations;
    }

    /**
     * Load defaultMethod
     *
     * If defaultMethod is defined in JobAnnotation, this one is used.
     * Otherwise is used set in Class
     *
     * @param JobAnnotation $jobAnnotation   JobAnnotation class
     * @param array         $defaultSettings Default settings for Worker
     *
     * @return string Default method
     */
    private function loadDefaultMethod(JobAnnotation $jobAnnotation, array $defaultSettings)
    {
        return is_null($jobAnnotation->defaultMethod)
            ? $defaultSettings['method']
            : $jobAnnotation->defaultMethod;
    }

    /**
     * Load minimumExecutionTime
     *
     * If minimumExecutionTime is defined in JobAnnotation, this one is used.
     * Otherwise is used set in Class
     *
     * @param JobAnnotation $jobAnnotation
     * @param array $defaultSettings
     *
     * @return int
     */
    private function loadMinimumExecutionTime(JobAnnotation $jobAnnotation, array $defaultSettings)
    {
        return is_null($jobAnnotation->minimumExecutionTime)
            ? (int) $defaultSettings['minimumExecutionTime']
            : (int) $jobAnnotation->minimumExecutionTime;
    }

    /**
     * Load timeout
     *
     * If timeout is defined in JobAnnotation, this one is used.
     * Otherwise is used set in Class
     *
     * @param JobAnnotation $jobAnnotation
     * @param array $defaultSettings
     *
     * @return int
     */
    private function loadTimeout(JobAnnotation $jobAnnotation, array $defaultSettings)
    {
        return is_null($jobAnnotation->timeout)
            ? (int) $defaultSettings['timeout']
            : (int) $jobAnnotation->timeout;
    }

    /**
     * Retrieve all Job data in cache format
     *
     * @return array

     */
    public function toArray()
    {
        return array(

            'callableName'             => $this->callableName,
            'methodName'               => $this->methodName,
            'realCallableName'         => $this->realCallableName,
            'jobPrefix'                => $this->jobPrefix,
            'realCallableNameNoPrefix' => $this->realCallableNameNoPrefix,
            'description'              => $this->description,
            'iterations'               => $this->iterations,
            'minimumExecutionTime'     => $this->minimumExecutionTime,
            'timeout'                  => $this->timeout,
            'servers'                  => $this->servers,
            'defaultMethod'            => $this->defaultMethod,
        );
    }

    /**
     * Sets the container.
     *
     * @param ContainerInterface|null $container A ContainerInterface instance or null
     */
    public function setContainer(ContainerInterface $container = null)
    {
        $this->container = $container;
    }
}



1		<?php
2
3		/**
4		* Gearman Bundle for Symfony2
5		*
6		* For the full copyright and license information, please view the LICENSE
7		* file that was distributed with this source code.
8		*
9		* Feel free to edit as you please, and have fun.
10		*
11		* @author Marc Morera <[email protected]>
12		*/
13
14		namespace Mmoreram\GearmanBundle\Module;
15
16		use ReflectionMethod;
17		use Symfony\Component\DependencyInjection\ContainerAwareInterface;
18		use Symfony\Component\DependencyInjection\ContainerInterface;
19
20		use Mmoreram\GearmanBundle\Driver\Gearman\Job as JobAnnotation;
21
22		/**
23		* Job class
24		*
25		* This class provide all worker definition.
26		*
27		* @since 2.3.1
28		*/
29		class JobClass implements ContainerAwareInterface
30		{
31		/**
32		* @var string
33		*
34		* Default description when is not defined
35		*/
36		const DEFAULT_DESCRIPTION = 'No description is defined';
37
38		/**
39		* @var string
40		*
41		* Callable name for this job
42		* If is setted on annotations, this value will be used
43		* otherwise, natural method name will be used.
44		*/
45		private $callableName;
46
47		/**
48		* @var string
49		*
50		* Method name
51		*/
52		private $methodName;
53
54		/**
55		* @var string
56		*
57		* RealCallable name for this job without the job prefix
58		*
59		*/
60		private $realCallableNameNoPrefix;
61
62		/**
63		* @var string
64		*
65		* RealCallable name for this job
66		* natural method name will be used.
67		*/
68		private $realCallableName;
69
70		/**
71		* @var string
72		*
73		* Description of Job
74		*/
75		private $description;
76
77		/**
78		* @var integer
79		*
80		* Number of iterations this job will be alive before die
81		*/
82		private $iterations;
83
84		/**
85		* @var string
86		*
87		* Default method this job will be call into Gearman client
88		*/
89		private $defaultMethod;
90
91		/**
92		* @var int
93		*
94		* Job minimum execution time
95		*/
96		private $minimumExecutionTime;
97
98		/**
99		* @var int
100		*
101		* Timeout for idle worker
102		*/
103		private $timeout;
104
105		/**
106		* @var array
107		*
108		* Collection of servers to connect
109		*/
110		private $servers;
111
112		/**
113		* @var string
114		*
115		* The prefix to be prepended to all job callable names.
116		*/
117		private $jobPrefix;
118
119		/**
120		* @var ContainerInterface
121		*/
122		protected $container;
123
124		/**
125		* Construct method
126		*
127		* @param JobAnnotation $jobAnnotation JobAnnotation class
128		* @param ReflectionMethod $reflectionMethod ReflextionMethod class
129		* @param string $callableNameClass Callable name class
130		* @param array $servers Array of servers defined for Worker
131		* @param array $defaultSettings Default settings for Worker
132		*/
133	18	public function __construct(
134		JobAnnotation $jobAnnotation,
135		ReflectionMethod $reflectionMethod,
136		$callableNameClass,
137		array $servers,
138		array $defaultSettings
139		)
140		{
141
142	18	$this->callableName = is_null($jobAnnotation->name)
143	15	? $reflectionMethod->getName()
144	3	: $jobAnnotation->name;
145
146	18	$this->methodName = $reflectionMethod->getName();
		0 ignored issues – show Coding Style introduced 2016-11-11 12:39 UTC by Report Bug Copy Issue Report Equals sign not aligned with surrounding assignments; expected 15 spaces but found 1 space This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a"; $ab = "ab"; $abc = "abc"; will produce issues in the first and second line, while this second example $a = "a"; $ab = "ab"; $abc = "abc"; will produce no issues. Loading history...
147	18	$this->realCallableNameNoPrefix = is_null($jobAnnotation->realCallableName)
148	12	? str_replace('\\', '', $callableNameClass . '~' . $this->callableName)
149	6	: $jobAnnotation->realCallableName;
150
151	18	$this->jobPrefix = isset($defaultSettings['jobPrefix'])
152	6	? $defaultSettings['jobPrefix']
153	12	: null;
154
155	18	$this->realCallableName = $this->jobPrefix . $this->realCallableNameNoPrefix;
156	18	$this->description = is_null($jobAnnotation->description)
		0 ignored issues – show Coding Style introduced 2016-11-11 12:39 UTC by Report Bug Copy Issue Report Equals sign not aligned with surrounding assignments; expected 6 spaces but found 1 space This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a"; $ab = "ab"; $abc = "abc"; will produce issues in the first and second line, while this second example $a = "a"; $ab = "ab"; $abc = "abc"; will produce no issues. Loading history...
157	15	? self::DEFAULT_DESCRIPTION
158	3	: $jobAnnotation->description;
159
160	18	$this->servers = $this->loadServers($jobAnnotation, $servers);
		0 ignored issues – show Coding Style introduced 2016-11-11 12:39 UTC by Report Bug Copy Issue Report Equals sign not aligned with surrounding assignments; expected 14 spaces but found 1 space This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a"; $ab = "ab"; $abc = "abc"; will produce issues in the first and second line, while this second example $a = "a"; $ab = "ab"; $abc = "abc"; will produce no issues. Loading history...
161	18	$this->iterations = $this->loadIterations($jobAnnotation, $defaultSettings);
		0 ignored issues – show Coding Style introduced 2016-11-11 12:39 UTC by Report Bug Copy Issue Report Equals sign not aligned with surrounding assignments; expected 11 spaces but found 1 space This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a"; $ab = "ab"; $abc = "abc"; will produce issues in the first and second line, while this second example $a = "a"; $ab = "ab"; $abc = "abc"; will produce no issues. Loading history...
162	18	$this->minimumExecutionTime = $this->loadMinimumExecutionTime($jobAnnotation, $defaultSettings);
163	18	$this->timeout = $this->loadTimeout($jobAnnotation, $defaultSettings);
		0 ignored issues – show Coding Style introduced 2016-11-11 12:39 UTC by Report Bug Copy Issue Report Equals sign not aligned with surrounding assignments; expected 14 spaces but found 1 space This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a"; $ab = "ab"; $abc = "abc"; will produce issues in the first and second line, while this second example $a = "a"; $ab = "ab"; $abc = "abc"; will produce no issues. Loading history...
164	18	$this->defaultMethod = $this->loadDefaultMethod($jobAnnotation, $defaultSettings);
		0 ignored issues – show Coding Style introduced 2016-11-11 12:39 UTC by Report Bug Copy Issue Report Equals sign not aligned with surrounding assignments; expected 8 spaces but found 1 space This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a"; $ab = "ab"; $abc = "abc"; will produce issues in the first and second line, while this second example $a = "a"; $ab = "ab"; $abc = "abc"; will produce no issues. Loading history...
165	18	}
166
167		/**
168		* Load servers
169		*
170		* If any server is defined in JobAnnotation, this one is used.
171		* Otherwise is used servers set in Class
172		*
173		* @param JobAnnotation $jobAnnotation JobAnnotation class
174		* @param array $servers Array of servers defined for Worker
175		*
176		* @return array Servers
177		*/
178	18	private function loadServers(JobAnnotation $jobAnnotation, array $servers)
179		{
180
181		/**
182		* If is configured some servers definition in the worker, overwrites
183		*/
184	18	if ($jobAnnotation->servers) {
185
186	9	$servers = (is_array($jobAnnotation->servers) && !isset($jobAnnotation->servers['host']))
		0 ignored issues – show Coding Style introduced 2016-11-11 12:39 UTC by Report Bug Copy Issue Report Consider using a different name than the parameter `$servers`. This often makes code more readable. Loading history...
187	3	? $jobAnnotation->servers
188	9	: array($jobAnnotation->servers);
189		}
190
191	18	return $servers;
192		}
193
194		/**
195		* Load iterations
196		*
197		* If iterations is defined in JobAnnotation, this one is used.
198		* Otherwise is used set in Class
199		*
200		* @param JobAnnotation $jobAnnotation JobAnnotation class
201		* @param array $defaultSettings Default settings for Worker
202		*
203		* @return integer Iteration
204		*/
205	18	private function loadIterations(JobAnnotation $jobAnnotation, array $defaultSettings)
206		{
207	18	return is_null($jobAnnotation->iterations)
208	15	? (int) $defaultSettings['iterations']
209	18	: (int) $jobAnnotation->iterations;
210		}
211
212		/**
213		* Load defaultMethod
214		*
215		* If defaultMethod is defined in JobAnnotation, this one is used.
216		* Otherwise is used set in Class
217		*
218		* @param JobAnnotation $jobAnnotation JobAnnotation class
219		* @param array $defaultSettings Default settings for Worker
220		*
221		* @return string Default method
222		*/
223	18	private function loadDefaultMethod(JobAnnotation $jobAnnotation, array $defaultSettings)
224		{
225	18	return is_null($jobAnnotation->defaultMethod)
226	15	? $defaultSettings['method']
227	18	: $jobAnnotation->defaultMethod;
228		}
229
230		/**
231		* Load minimumExecutionTime
232		*
233		* If minimumExecutionTime is defined in JobAnnotation, this one is used.
234		* Otherwise is used set in Class
235		*
236		* @param JobAnnotation $jobAnnotation
237		* @param array $defaultSettings
238		*
239		* @return int
240		*/
241	18	private function loadMinimumExecutionTime(JobAnnotation $jobAnnotation, array $defaultSettings)
242		{
243	18	return is_null($jobAnnotation->minimumExecutionTime)
244	18	? (int) $defaultSettings['minimumExecutionTime']
245	18	: (int) $jobAnnotation->minimumExecutionTime;
246		}
247
248		/**
249		* Load timeout
250		*
251		* If timeout is defined in JobAnnotation, this one is used.
252		* Otherwise is used set in Class
253		*
254		* @param JobAnnotation $jobAnnotation
255		* @param array $defaultSettings
256		*
257		* @return int
258		*/
259	18	private function loadTimeout(JobAnnotation $jobAnnotation, array $defaultSettings)
260		{
261	18	return is_null($jobAnnotation->timeout)
262	18	? (int) $defaultSettings['timeout']
263	18	: (int) $jobAnnotation->timeout;
264		}
265
266		/**
267		* Retrieve all Job data in cache format
268		*
269		* @return array
		0 ignored issues – show Documentation introduced 2016-11-11 12:39 UTC by Report Bug Copy Issue Report Consider making the return type a bit more specific; maybe use `array<string,string\|integer\|array>`. This check looks for the generic type `array` as a return type and suggests a more specific type. This type is inferred from the actual code. Loading history...
270		*/
271	18	public function toArray()
272		{
273		return array(
274
275	18	'callableName' => $this->callableName,
276	18	'methodName' => $this->methodName,
277	18	'realCallableName' => $this->realCallableName,
278	18	'jobPrefix' => $this->jobPrefix,
279	18	'realCallableNameNoPrefix' => $this->realCallableNameNoPrefix,
280	18	'description' => $this->description,
281	18	'iterations' => $this->iterations,
282	18	'minimumExecutionTime' => $this->minimumExecutionTime,
283	18	'timeout' => $this->timeout,
284	18	'servers' => $this->servers,
285	18	'defaultMethod' => $this->defaultMethod,
286		);
287		}
288
289		/**
290		* Sets the container.
291		*
292		* @param ContainerInterface\|null $container A ContainerInterface instance or null
293		*/
294		public function setContainer(ContainerInterface $container = null)
295		{
296		$this->container = $container;
297		}
298		}
		0 ignored issues – show Coding Style introduced 2016-11-11 12:39 UTC by Report Bug Copy Issue Report As per coding style, files should not end with a newline character. This check marks files that end in a newline character, i.e. an empy line. Loading history...
299

mikaelkael / GearmanBundle

Push — master ( 079541...355f41 )

JobClass A

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

8 Methods

Duplication Side-by-Side

Filter issues like