MetadataCollector - Code Metrics - Inspection of "Changed analysis collection from config to documen..." - ongr-io/ElasticsearchBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — 5.0 (#720)

unknown

created 2016-11-23 07:15 UTC

MetadataCollector B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	366
Duplicated Lines	1.64 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes

Metric	Value
wmc	43
c	0
b	0
f	0
lcom	1
cbo	3
dl	6
loc	366
rs	8.3157

15 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	10	2
A	setEnableCache()	0	4	1
A	setAnalysisConfiguration()	0	4	1
A	getMappings()	0	20	3
C	getBundleMapping()	0	58	9
A	getManagerTypes()	0	6	1
A	getDocumentType()	0	6	1
B	getClientMapping()	0	24	4
B	getManagerAnalysis()	0	24	5
A	getDocumentReflectionMapping()	0	4	1
A	getMapping()	0	13	2
A	cacheBundle()	0	7	2
A	getClassName()	0	4	1
A	extractAnalysisFromProperties()	0	17	4
B	extractSubData()	6	20	6

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like MetadataCollector often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use MetadataCollector, and based on these observations, apply Extract Interface, too.

<?php

/*
 * This file is part of the ONGR package.
 *
 * (c) NFQ Technologies UAB <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace ONGR\ElasticsearchBundle\Mapping;

use Doctrine\Common\Cache\CacheProvider;
use ONGR\ElasticsearchBundle\Mapping\Exception\DocumentParserException;
use ONGR\ElasticsearchBundle\Mapping\Exception\MissingDocumentAnnotationException;

/**
 * DocumentParser wrapper for getting bundle documents mapping.
 */
class MetadataCollector
{
    /**
     * @var DocumentFinder
     */
    private $finder;

    /**
     * @var DocumentParser
     */
    private $parser;

    /**
     * @var CacheProvider
     */
    private $cache = null;

    /**
     * @var bool
     */
    private $enableCache = false;

    /**
     * @var array
     */
    private $analysisConfiguration;

    /**
     * Bundles mappings local cache container. Could be stored as the whole bundle or as single document.
     * e.g. AcmeDemoBundle, AcmeDemoBundle:Product.
     *
     * @var mixed
     */
    private $mappings = [];

    /**
     * @param DocumentFinder $finder For finding documents.
     * @param DocumentParser $parser For reading document annotations.
     * @param CacheProvider  $cache  Cache provider to store the meta data for later use.
     */
    public function __construct($finder, $parser, $cache = null)
    {
        $this->finder = $finder;
        $this->parser = $parser;
        $this->cache = $cache;

        if ($this->cache) {
            $this->mappings = $this->cache->fetch('ongr.metadata.mappings');
        }
    }

    /**
     * Enables metadata caching.
     *
     * @param bool $enableCache
     */
    public function setEnableCache($enableCache)
    {
        $this->enableCache = $enableCache;
    }

    /**
     * @param array $config
     */
    public function setAnalysisConfiguration(array $config)
    {
        $this->analysisConfiguration = $config;
    }

    /**
     * Fetches bundles mapping from documents.
     *
     * @param string[] $bundles Elasticsearch manager config. You can get bundles list from 'mappings' node.
     * @return array
     */
    public function getMappings(array $bundles)
    {
        $output = [];
        foreach ($bundles as $bundle) {
            $mappings = $this->getBundleMapping($bundle);

            $alreadyDefinedTypes = array_intersect_key($mappings, $output);
            if (count($alreadyDefinedTypes)) {
                throw new \LogicException(
                    implode(',', array_keys($alreadyDefinedTypes)) .
                    ' type(s) already defined in other document, you can use the same ' .
                    'type only once in a manager definition.'
                );
            }

            $output = array_merge($output, $mappings);
        }

        return $output;
    }

    /**
     * Searches for documents in the bundle and tries to read them.
     *
     * @param string $name
     *
     * @return array Empty array on containing zero documents.
     */
    public function getBundleMapping($name)
    {
        if (!is_string($name)) {
            throw new \LogicException('getBundleMapping() in the Metadata collector expects a string argument only!');
        }

        if (isset($this->mappings[$name])) {
            return $this->mappings[$name];
        }

        // Handle the case when single document mapping requested
        if (strpos($name, ':') !== false) {
            list($bundle, $documentClass) = explode(':', $name);
            $documents = $this->finder->getBundleDocumentClasses($bundle);
            $documents = in_array($documentClass, $documents) ? [$documentClass] : [];
        } else {
            $documents = $this->finder->getBundleDocumentClasses($name);
            $bundle = $name;
        }

        $mappings = [];
        $bundleNamespace = $this->finder->getBundleClass($bundle);
        $bundleNamespace = substr($bundleNamespace, 0, strrpos($bundleNamespace, '\\'));

        if (!count($documents)) {
            return [];
        }

        // Loop through documents found in bundle.
        foreach ($documents as $document) {
            $documentReflection = new \ReflectionClass(
                $bundleNamespace .
                '\\' . DocumentFinder::DOCUMENT_DIR .
                '\\' . $document
            );

            try {
                $documentMapping = $this->getDocumentReflectionMapping($documentReflection);
            } catch (MissingDocumentAnnotationException $exception) {
                // Not a document, just ignore
                continue;
            }

            if (!array_key_exists($documentMapping['type'], $mappings)) {
                $documentMapping['bundle'] = $bundle;
                $mappings = array_merge($mappings, [$documentMapping['type'] => $documentMapping]);
            } else {
                throw new \LogicException(
                    $bundle . ' has 2 same type names defined in the documents. ' .
                    'Type names must be unique!'
                );
            }
        }

        $this->cacheBundle($name, $mappings);

        return $mappings;
    }

    /**
     * @param array $manager
     *
     * @return array
     */
    public function getManagerTypes($manager)
    {
        $mapping = $this->getMappings($manager['mappings']);

        return array_keys($mapping);
    }

    /**
     * Resolves Elasticsearch type by document class.
     *
     * @param string $className FQCN or string in AppBundle:Document format
     *
     * @return string
     */
    public function getDocumentType($className)
    {
        $mapping = $this->getMapping($className);

        return $mapping['type'];
    }

    /**
     * Retrieves prepared mapping to sent to the elasticsearch client.
     *
     * @param array $bundles Manager config.
     *
     * @return array|null
     */
    public function getClientMapping(array $bundles)
    {
        /** @var array $typesMapping Array of filtered mappings for the elasticsearch client*/
        $typesMapping = null;

        /** @var array $mappings All mapping info */
        $mappings = $this->getMappings($bundles);

        foreach ($mappings as $type => $mapping) {
            if (!empty($mapping['properties'])) {
                $typesMapping[$type] = array_filter(
                    array_merge(
                        ['properties' => $mapping['properties']],
                        $mapping['fields']
                    ),
                    function ($value) {
                        return (bool)$value || is_bool($value);
                    }
                );
            }
        }

        return $typesMapping;
    }

    /**
     * Gets the analysis configuration from the documents of the specific bundles
     *
     * @param string $manager Manager name
     * @param array  $bundles
     *
     * @return array
     */
    public function getManagerAnalysis($manager, array $bundles)
    {
        if ($this->cache) {
            $cacheAnalysis = $this->cache->fetch('ongr.metadata.analysis');

            if (isset($cacheAnalysis[$manager])) {
                return $cacheAnalysis[$manager];
            }
        }

        $managerAnalysis = [];
        $mappings = $this->getClientMapping($bundles);

        foreach ($mappings as $type) {
$collection = json_decode($data, true);
if ( ! is_array($collection)) {
    throw new \RuntimeException('$collection must be an array.');
}

foreach ($collection as $item) { /** ... */ }
            $this->extractAnalysisFromProperties($type['properties'], $managerAnalysis);
        }

        if ($this->enableCache) {
            $cacheAnalysis[$manager] = array_filter($managerAnalysis);
function myFunction($a) {
    switch ($a) {
        case 'foo':
            $x = 1;
            break;

        case 'bar':
            $x = 2;
            break;
    }

    // $x is potentially undefined here.
    echo $x;
}
            $this->cache->save('ongr.metadata.analysis', $cacheAnalysis);
        }

        return array_filter($managerAnalysis);
    }

    /**
     * Gathers annotation data from class.
     *
     * @param \ReflectionClass $reflectionClass Document reflection class to read mapping from.
     *
     * @return array
     * @throws DocumentParserException
     */
    private function getDocumentReflectionMapping(\ReflectionClass $reflectionClass)
    {
        return $this->parser->parse($reflectionClass);
    }

    /**
     * Returns single document mapping metadata.
     *
     * @param string $namespace Document namespace
     *
     * @return array
     * @throws DocumentParserException
     */
    public function getMapping($namespace)
    {
        $namespace = $this->getClassName($namespace);

        if (isset($this->mappings[$namespace])) {
            return $this->mappings[$namespace];
        }

        $mapping = $this->getDocumentReflectionMapping(new \ReflectionClass($namespace));
        $this->cacheBundle($namespace, $mapping);

        return $mapping;
    }

    /**
     * Adds metadata information to the cache storage.
     *
     * @param string $bundle
     * @param array  $mapping
     */
    private function cacheBundle($bundle, array $mapping)
    {
        if ($this->enableCache) {
            $this->mappings[$bundle] = $mapping;
            $this->cache->save('ongr.metadata.mappings', $this->mappings);
        }
    }

    /**
     * Returns fully qualified class name.
     *
     * @param string $className
     *
     * @return string
     */
    public function getClassName($className)
    {
        return $this->finder->getNamespace($className);
    }

    /**
     * Extracts analysis configuration from all the documents
     *
     * @param array $properties      Properties of a type or an object
     * @param array $managerAnalysis The data that is being formed for the manager
     */
    private function extractAnalysisFromProperties($properties, &$managerAnalysis)
    {
        foreach ($properties as $property) {
            if (isset($property['analyzer'])) {
                $analyzer = $this->analysisConfiguration['analyzer'][$property['analyzer']];
                $managerAnalysis['analyzer'][$property['analyzer']] = $analyzer;

                $this->extractSubData('filter', $analyzer, $managerAnalysis);
                $this->extractSubData('char_filter', $analyzer, $managerAnalysis);
                $this->extractSubData('tokenizer', $analyzer, $managerAnalysis);
            }

            if (isset($property['properties'])) {
                $this->extractAnalysisFromProperties($property['properties'], $managerAnalysis);
            }
        }
    }

    /**
     * Extracts tokenizers and filters from analysis configuration
     *
     * @param string $type     Either filter or tokenizer
     * @param array  $analyzer The current analyzer
     * @param array  $data     The data that is being formed for the manager
     */
    private function extractSubData($type, $analyzer, &$data)
    {
        if (!isset($analyzer[$type])) {
            return;
        }

        if (is_array($analyzer[$type])) {
            foreach ($analyzer[$type] as $name) {
                if (isset($this->analysisConfiguration[$type][$name])) {

                    $data[$type][$name] = $this->analysisConfiguration[$type][$name];
                }
            }
        } else {
            $name = $analyzer[$type];

            if (isset($this->analysisConfiguration[$type][$name])) {

                $data[$type][$name] = $this->analysisConfiguration[$type][$name];
            }
        }
    }
}


1		<?php
2
3		/*
4		* This file is part of the ONGR package.
5		*
6		* (c) NFQ Technologies UAB <[email protected]>
7		*
8		* For the full copyright and license information, please view the LICENSE
9		* file that was distributed with this source code.
10		*/
11
12		namespace ONGR\ElasticsearchBundle\Mapping;
13
14		use Doctrine\Common\Cache\CacheProvider;
15		use ONGR\ElasticsearchBundle\Mapping\Exception\DocumentParserException;
16		use ONGR\ElasticsearchBundle\Mapping\Exception\MissingDocumentAnnotationException;
17
18		/**
19		* DocumentParser wrapper for getting bundle documents mapping.
20		*/
21		class MetadataCollector
22		{
23		/**
24		* @var DocumentFinder
25		*/
26		private $finder;
27
28		/**
29		* @var DocumentParser
30		*/
31		private $parser;
32
33		/**
34		* @var CacheProvider
35		*/
36		private $cache = null;
37
38		/**
39		* @var bool
40		*/
41		private $enableCache = false;
42
43		/**
44		* @var array
45		*/
46		private $analysisConfiguration;
47
48		/**
49		* Bundles mappings local cache container. Could be stored as the whole bundle or as single document.
50		* e.g. AcmeDemoBundle, AcmeDemoBundle:Product.
51		*
52		* @var mixed
53		*/
54		private $mappings = [];
55
56		/**
57		* @param DocumentFinder $finder For finding documents.
58		* @param DocumentParser $parser For reading document annotations.
59		* @param CacheProvider $cache Cache provider to store the meta data for later use.
60		*/
61		public function __construct($finder, $parser, $cache = null)
62		{
63		$this->finder = $finder;
64		$this->parser = $parser;
65		$this->cache = $cache;
66
67		if ($this->cache) {
68		$this->mappings = $this->cache->fetch('ongr.metadata.mappings');
69		}
70		}
71
72		/**
73		* Enables metadata caching.
74		*
75		* @param bool $enableCache
76		*/
77		public function setEnableCache($enableCache)
78		{
79		$this->enableCache = $enableCache;
80		}
81
82		/**
83		* @param array $config
84		*/
85		public function setAnalysisConfiguration(array $config)
86		{
87		$this->analysisConfiguration = $config;
88		}
89
90		/**
91		* Fetches bundles mapping from documents.
92		*
93		* @param string[] $bundles Elasticsearch manager config. You can get bundles list from 'mappings' node.
94		* @return array
95		*/
96		public function getMappings(array $bundles)
97		{
98		$output = [];
99		foreach ($bundles as $bundle) {
100		$mappings = $this->getBundleMapping($bundle);
101
102		$alreadyDefinedTypes = array_intersect_key($mappings, $output);
103		if (count($alreadyDefinedTypes)) {
104		throw new \LogicException(
105		implode(',', array_keys($alreadyDefinedTypes)) .
106		' type(s) already defined in other document, you can use the same ' .
107		'type only once in a manager definition.'
108		);
109		}
110
111		$output = array_merge($output, $mappings);
112		}
113
114		return $output;
115		}
116
117		/**
118		* Searches for documents in the bundle and tries to read them.
119		*
120		* @param string $name
121		*
122		* @return array Empty array on containing zero documents.
123		*/
124		public function getBundleMapping($name)
125		{
126		if (!is_string($name)) {
127		throw new \LogicException('getBundleMapping() in the Metadata collector expects a string argument only!');
128		}
129
130		if (isset($this->mappings[$name])) {
131		return $this->mappings[$name];
132		}
133
134		// Handle the case when single document mapping requested
135		if (strpos($name, ':') !== false) {
136		list($bundle, $documentClass) = explode(':', $name);
137		$documents = $this->finder->getBundleDocumentClasses($bundle);
138		$documents = in_array($documentClass, $documents) ? [$documentClass] : [];
139		} else {
140		$documents = $this->finder->getBundleDocumentClasses($name);
141		$bundle = $name;
142		}
143
144		$mappings = [];
145		$bundleNamespace = $this->finder->getBundleClass($bundle);
146		$bundleNamespace = substr($bundleNamespace, 0, strrpos($bundleNamespace, '\\'));
147
148		if (!count($documents)) {
149		return [];
150		}
151
152		// Loop through documents found in bundle.
153		foreach ($documents as $document) {
154		$documentReflection = new \ReflectionClass(
155		$bundleNamespace .
156		'\\' . DocumentFinder::DOCUMENT_DIR .
157		'\\' . $document
158		);
159
160		try {
161		$documentMapping = $this->getDocumentReflectionMapping($documentReflection);
162		} catch (MissingDocumentAnnotationException $exception) {
163		// Not a document, just ignore
164		continue;
165		}
166
167		if (!array_key_exists($documentMapping['type'], $mappings)) {
168		$documentMapping['bundle'] = $bundle;
169		$mappings = array_merge($mappings, [$documentMapping['type'] => $documentMapping]);
170		} else {
171		throw new \LogicException(
172		$bundle . ' has 2 same type names defined in the documents. ' .
173		'Type names must be unique!'
174		);
175		}
176		}
177
178		$this->cacheBundle($name, $mappings);
179
180		return $mappings;
181		}
182
183		/**
184		* @param array $manager
185		*
186		* @return array
187		*/
188		public function getManagerTypes($manager)
189		{
190		$mapping = $this->getMappings($manager['mappings']);
191
192		return array_keys($mapping);
193		}
194
195		/**
196		* Resolves Elasticsearch type by document class.
197		*
198		* @param string $className FQCN or string in AppBundle:Document format
199		*
200		* @return string
201		*/
202		public function getDocumentType($className)
203		{
204		$mapping = $this->getMapping($className);
205
206		return $mapping['type'];
207		}
208
209		/**
210		* Retrieves prepared mapping to sent to the elasticsearch client.
211		*
212		* @param array $bundles Manager config.
213		*
214		* @return array\|null
215		*/
216		public function getClientMapping(array $bundles)
217		{
218		/** @var array $typesMapping Array of filtered mappings for the elasticsearch client*/
219		$typesMapping = null;
220
221		/** @var array $mappings All mapping info */
222		$mappings = $this->getMappings($bundles);
223
224		foreach ($mappings as $type => $mapping) {
225		if (!empty($mapping['properties'])) {
226		$typesMapping[$type] = array_filter(
227		array_merge(
228		['properties' => $mapping['properties']],
229		$mapping['fields']
230		),
231		function ($value) {
232		return (bool)$value \|\| is_bool($value);
233		}
234		);
235		}
236		}
237
238		return $typesMapping;
239		}
240
241		/**
242		* Gets the analysis configuration from the documents of the specific bundles
243		*
244		* @param string $manager Manager name
245		* @param array $bundles
246		*
247		* @return array
248		*/
249		public function getManagerAnalysis($manager, array $bundles)
250		{
251		if ($this->cache) {
252		$cacheAnalysis = $this->cache->fetch('ongr.metadata.analysis');
253
254		if (isset($cacheAnalysis[$manager])) {
255		return $cacheAnalysis[$manager];
256		}
257		}
258
259		$managerAnalysis = [];
260		$mappings = $this->getClientMapping($bundles);
261
262		foreach ($mappings as $type) {
		0 ignored issues – show Bug introduced 2016-11-22 14:01 UTC by Report Bug Copy Issue Report The expression `$mappings` of type `array\|null` is not guaranteed to be traversable. How about adding an additional type check? There are different options of fixing this problem. If you want to be on the safe side, you can add an additional type-check: $collection = json_decode($data, true); if ( ! is_array($collection)) { throw new \RuntimeException('$collection must be an array.'); } foreach ($collection as $item) { /** ... / } If you are sure that the expression is traversable, you might want to add a doc comment cast* to improve IDE auto-completion and static analysis: /** @var array $collection / $collection = json_decode($data, true); foreach ($collection as $item) { /* .. / } Mark the issue as a false-positive*: Just hover the remove button, in the top-right corner of this issue for more options. Loading history...
263		$this->extractAnalysisFromProperties($type['properties'], $managerAnalysis);
264		}
265
266		if ($this->enableCache) {
267		$cacheAnalysis[$manager] = array_filter($managerAnalysis);
		0 ignored issues – show Bug introduced 2016-11-23 07:17 UTC by Report Bug Copy Issue Report The variable `$cacheAnalysis` does not seem to be defined for all execution paths leading up to this point. If you define a variable conditionally, it can happen that it is not defined for all execution paths. Let’s take a look at an example: function myFunction($a) { switch ($a) { case 'foo': $x = 1; break; case 'bar': $x = 2; break; } // $x is potentially undefined here. echo $x; } In the above example, the variable `$x` is defined if you pass “foo” or “bar” as argument for `$a`. However, since the `switch` statement has no default case statement, if you pass any other value, the variable `$x` would be undefined. Available Fixes Check for existence of the variable explicitly: function myFunction($a) { switch ($a) { case 'foo': $x = 1; break; case 'bar': $x = 2; break; } if (isset($x)) { // Make sure it's always set. echo $x; } } Define a default value for the variable: function myFunction($a) { $x = ''; // Set a default which gets overridden for certain paths. switch ($a) { case 'foo': $x = 1; break; case 'bar': $x = 2; break; } echo $x; } Add a value for the missing path: function myFunction($a) { switch ($a) { case 'foo': $x = 1; break; case 'bar': $x = 2; break; // We add support for the missing case. default: $x = ''; break; } echo $x; } Loading history...
268		$this->cache->save('ongr.metadata.analysis', $cacheAnalysis);
269		}
270
271		return array_filter($managerAnalysis);
272		}
273
274		/**
275		* Gathers annotation data from class.
276		*
277		* @param \ReflectionClass $reflectionClass Document reflection class to read mapping from.
278		*
279		* @return array
280		* @throws DocumentParserException
281		*/
282		private function getDocumentReflectionMapping(\ReflectionClass $reflectionClass)
283		{
284		return $this->parser->parse($reflectionClass);
285		}
286
287		/**
288		* Returns single document mapping metadata.
289		*
290		* @param string $namespace Document namespace
291		*
292		* @return array
293		* @throws DocumentParserException
294		*/
295		public function getMapping($namespace)
296		{
297		$namespace = $this->getClassName($namespace);
298
299		if (isset($this->mappings[$namespace])) {
300		return $this->mappings[$namespace];
301		}
302
303		$mapping = $this->getDocumentReflectionMapping(new \ReflectionClass($namespace));
304		$this->cacheBundle($namespace, $mapping);
305
306		return $mapping;
307		}
308
309		/**
310		* Adds metadata information to the cache storage.
311		*
312		* @param string $bundle
313		* @param array $mapping
314		*/
315		private function cacheBundle($bundle, array $mapping)
316		{
317		if ($this->enableCache) {
318		$this->mappings[$bundle] = $mapping;
319		$this->cache->save('ongr.metadata.mappings', $this->mappings);
320		}
321		}
322
323		/**
324		* Returns fully qualified class name.
325		*
326		* @param string $className
327		*
328		* @return string
329		*/
330		public function getClassName($className)
331		{
332		return $this->finder->getNamespace($className);
333		}
334
335		/**
336		* Extracts analysis configuration from all the documents
337		*
338		* @param array $properties Properties of a type or an object
339		* @param array $managerAnalysis The data that is being formed for the manager
340		*/
341		private function extractAnalysisFromProperties($properties, &$managerAnalysis)
342		{
343		foreach ($properties as $property) {
344		if (isset($property['analyzer'])) {
345		$analyzer = $this->analysisConfiguration['analyzer'][$property['analyzer']];
346		$managerAnalysis['analyzer'][$property['analyzer']] = $analyzer;
347
348		$this->extractSubData('filter', $analyzer, $managerAnalysis);
349		$this->extractSubData('char_filter', $analyzer, $managerAnalysis);
350		$this->extractSubData('tokenizer', $analyzer, $managerAnalysis);
351		}
352
353		if (isset($property['properties'])) {
354		$this->extractAnalysisFromProperties($property['properties'], $managerAnalysis);
355		}
356		}
357		}
358
359		/**
360		* Extracts tokenizers and filters from analysis configuration
361		*
362		* @param string $type Either filter or tokenizer
363		* @param array $analyzer The current analyzer
364		* @param array $data The data that is being formed for the manager
365		*/
366		private function extractSubData($type, $analyzer, &$data)
367		{
368		if (!isset($analyzer[$type])) {
369		return;
370		}
371
372		if (is_array($analyzer[$type])) {
373		foreach ($analyzer[$type] as $name) {
374	View Code Duplication	if (isset($this->analysisConfiguration[$type][$name])) {
		0 ignored issues – show Duplication introduced 2016-11-23 07:17 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
375		$data[$type][$name] = $this->analysisConfiguration[$type][$name];
376		}
377		}
378		} else {
379		$name = $analyzer[$type];
380
381	View Code Duplication	if (isset($this->analysisConfiguration[$type][$name])) {
		0 ignored issues – show Duplication introduced 2016-11-23 07:17 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
382		$data[$type][$name] = $this->analysisConfiguration[$type][$name];
383		}
384		}
385		}
386		}
387

ongr-io / ElasticsearchBundle