AbstractProvider::__construct() - Code Metrics - Inspection of "Fixed PropelCollection to array casting error" - FriendsOfSymfony/FOSElasticaBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#992)

by David

created 2015-12-28 14:40 UTC

AbstractProvider::__construct() A

↳ Parent: AbstractProvider

Complexity

Conditions	1
Paths	1

Size

Total Lines	13
Code Lines	11

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	7
CRAP Score	1.002

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	13
ccs	7
cts	8
cp	0.875
rs	9.4286
cc	1
eloc	11
nc	1
nop	4
crap	1.002

<?php

namespace FOS\ElasticaBundle\Provider;

use FOS\ElasticaBundle\Persister\ObjectPersisterInterface;
use Symfony\Component\OptionsResolver\OptionsResolver;

/**
 * AbstractProvider.
 */
abstract class AbstractProvider implements ProviderInterface
{
    /**
     * @var array
     */
    protected $baseOptions;

    /**
     * @var string
     */
    protected $objectClass;

    /**
     * @var ObjectPersisterInterface
     */
    protected $objectPersister;

    /**
     * @var OptionsResolver
     */
    protected $resolver;

    /**
     * @var IndexableInterface
     */
    private $indexable;

    /**
     * Constructor.
     *
     * @param ObjectPersisterInterface $objectPersister
     * @param IndexableInterface       $indexable
     * @param string                   $objectClass
     * @param array                    $baseOptions
     */
    public function __construct(
        ObjectPersisterInterface $objectPersister,
        IndexableInterface $indexable,
        $objectClass,
        array $baseOptions = array()
    ) {
        $this->baseOptions = $baseOptions;
        $this->indexable = $indexable;
        $this->objectClass = $objectClass;
        $this->objectPersister = $objectPersister;
        $this->resolver = new OptionsResolver();
        $this->configureOptions();
    }

    /**
     * {@inheritDoc}
     */
    public function populate(\Closure $loggerClosure = null, array $options = array())
    {
        $options = $this->resolveOptions($options);

        $logger = !$options['debug_logging'] ?
            $this->disableLogging() :
            null;

        $this->doPopulate($options, $loggerClosure);

        if (null !== $logger) {
            $this->enableLogging($logger);
        }
    }

    /**
     * Disables logging and returns the logger that was previously set.
     *
     * @return mixed
     */
    abstract protected function disableLogging();

    /**
     * Perform actual population.
     *
     * @param array $options
     * @param \Closure $loggerClosure
     */
    abstract protected function doPopulate($options, \Closure $loggerClosure = null);

    /**
     * Reenables the logger with the previously returned logger from disableLogging();.
     *
     * @param mixed $logger
     *
     * @return mixed
     */
    abstract protected function enableLogging($logger);

    /**
     * Configures the option resolver.
     */
    protected function configureOptions()
    {
        $this->resolver->setDefaults(array(
            'batch_size' => 100,
            'skip_indexable_check' => false,
        ));
        $this->resolver->setAllowedTypes(array(
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            'batch_size' => 'int'
        ));

        $this->resolver->setRequired(array(
            'indexName',
            'typeName',
        ));
    }


    /**
     * Filters objects away if they are not indexable.
     *
     * @param array $options
     * @param array $objects
     * @return array
     */
    protected function filterObjects(array $options, array $objects)
    {
        if ($options['skip_indexable_check']) {
            return $objects;
        }

        $index = $options['indexName'];
        $type = $options['typeName'];

        $return = array();
        foreach ($objects as $object) {
            if (!$this->indexable->isObjectIndexable($index, $type, $object)) {
                continue;
            }

            $return[] = $object;
        }

        return $return;
    }

    /**
     * Checks if a given object should be indexed or not.
     *
     * @deprecated To be removed in 4.0
     *
     * @param object $object
     *
     * @return bool
     */
    protected function isObjectIndexable($object)
    {
        return $this->indexable->isObjectIndexable(
            $this->baseOptions['indexName'],
            $this->baseOptions['typeName'],
            $object
        );
    }

    /**
     * Get string with RAM usage information (current and peak).
     *
     * @deprecated To be removed in 4.0
     *
     * @return string
     */
    protected function getMemoryUsage()
    {
        $memory = round(memory_get_usage() / (1024 * 1024)); // to get usage in Mo
        $memoryMax = round(memory_get_peak_usage() / (1024 * 1024)); // to get max usage in Mo

        return sprintf('(RAM : current=%uMo peak=%uMo)', $memory, $memoryMax);
    }

    /**
     * Merges the base options provided by the class with options passed to the populate
     * method and runs them through the resolver.
     *
     * @param array $options
     *
     * @return array
     */
    protected function resolveOptions(array $options)
    {
        return $this->resolver->resolve(array_merge($this->baseOptions, $options));
    }
}


1		<?php
2
3		namespace FOS\ElasticaBundle\Provider;
4
5		use FOS\ElasticaBundle\Persister\ObjectPersisterInterface;
6		use Symfony\Component\OptionsResolver\OptionsResolver;
7
8		/**
9		* AbstractProvider.
10		*/
11		abstract class AbstractProvider implements ProviderInterface
12		{
13		/**
14		* @var array
15		*/
16		protected $baseOptions;
17
18		/**
19		* @var string
20		*/
21		protected $objectClass;
22
23		/**
24		* @var ObjectPersisterInterface
25		*/
26		protected $objectPersister;
27
28		/**
29		* @var OptionsResolver
30		*/
31		protected $resolver;
32
33		/**
34		* @var IndexableInterface
35		*/
36		private $indexable;
37
38		/**
39		* Constructor.
40		*
41		* @param ObjectPersisterInterface $objectPersister
42		* @param IndexableInterface $indexable
43		* @param string $objectClass
44		* @param array $baseOptions
45		*/
46	9	public function __construct(
47		ObjectPersisterInterface $objectPersister,
48		IndexableInterface $indexable,
49		$objectClass,
50		array $baseOptions = array()
51		) {
52	9	$this->baseOptions = $baseOptions;
53	9	$this->indexable = $indexable;
54	9	$this->objectClass = $objectClass;
55	9	$this->objectPersister = $objectPersister;
56	9	$this->resolver = new OptionsResolver();
57	9	$this->configureOptions();
58		}
59
60		/**
61		* {@inheritDoc}
62		*/
63		public function populate(\Closure $loggerClosure = null, array $options = array())
64		{
65		$options = $this->resolveOptions($options);
66
67		$logger = !$options['debug_logging'] ?
68		$this->disableLogging() :
69		null;
70
71		$this->doPopulate($options, $loggerClosure);
72
73		if (null !== $logger) {
74		$this->enableLogging($logger);
75		}
76		}
77
78		/**
79		* Disables logging and returns the logger that was previously set.
80		*
81		* @return mixed
82		*/
83		abstract protected function disableLogging();
84
85		/**
86		* Perform actual population.
87		*
88		* @param array $options
89		* @param \Closure $loggerClosure
90		*/
91		abstract protected function doPopulate($options, \Closure $loggerClosure = null);
92
93		/**
94		* Reenables the logger with the previously returned logger from disableLogging();.
95		*
96		* @param mixed $logger
97		*
98		* @return mixed
99		*/
100		abstract protected function enableLogging($logger);
101
102		/**
103		* Configures the option resolver.
104		*/
105	9	protected function configureOptions()
106		{
107	9	$this->resolver->setDefaults(array(
108	9	'batch_size' => 100,
109		'skip_indexable_check' => false,
110		));
111	9	$this->resolver->setAllowedTypes(array(
		0 ignored issues – show Documentation introduced 2015-11-24 05:06 UTC by Report Bug Copy Issue Report `array('batch_size' => 'int')` is of type `array<string,string,{"batch_size":"string"}>`, but the function expects a `string`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history... Bug introduced 2015-12-04 19:12 UTC by Report Bug Copy Issue Report The call to `setAllowedTypes()` misses a required argument `$allowedTypes`. This check looks for function calls that miss required arguments. Loading history...
112		'batch_size' => 'int'
113	9	));
114
115		$this->resolver->setRequired(array(
116		'indexName',
117		'typeName',
118		));
119		}
120
121
122		/**
123		* Filters objects away if they are not indexable.
124		*
125		* @param array $options
126		* @param array $objects
127		* @return array
128		*/
129		protected function filterObjects(array $options, array $objects)
130		{
131		if ($options['skip_indexable_check']) {
132		return $objects;
133		}
134
135		$index = $options['indexName'];
136		$type = $options['typeName'];
137
138		$return = array();
139		foreach ($objects as $object) {
140		if (!$this->indexable->isObjectIndexable($index, $type, $object)) {
141		continue;
142		}
143
144		$return[] = $object;
145		}
146
147		return $return;
148		}
149
150		/**
151		* Checks if a given object should be indexed or not.
152		*
153		* @deprecated To be removed in 4.0
154		*
155		* @param object $object
156		*
157		* @return bool
158		*/
159		protected function isObjectIndexable($object)
160		{
161		return $this->indexable->isObjectIndexable(
162		$this->baseOptions['indexName'],
163		$this->baseOptions['typeName'],
164		$object
165		);
166		}
167
168		/**
169		* Get string with RAM usage information (current and peak).
170		*
171		* @deprecated To be removed in 4.0
172		*
173		* @return string
174		*/
175		protected function getMemoryUsage()
176		{
177		$memory = round(memory_get_usage() / (1024 * 1024)); // to get usage in Mo
178		$memoryMax = round(memory_get_peak_usage() / (1024 * 1024)); // to get max usage in Mo
179
180		return sprintf('(RAM : current=%uMo peak=%uMo)', $memory, $memoryMax);
181		}
182
183		/**
184		* Merges the base options provided by the class with options passed to the populate
185		* method and runs them through the resolver.
186		*
187		* @param array $options
188		*
189		* @return array
190		*/
191		protected function resolveOptions(array $options)
192		{
193		return $this->resolver->resolve(array_merge($this->baseOptions, $options));
194		}
195		}
196

FriendsOfSymfony / FOSElasticaBundle

Pull Request — master (#992)

AbstractProvider::__construct() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like