MetadataCollector::getAnalysisNodeConfiguration() - Code Metrics - Inspection of "Merge branch '5.0'" - ongr-io/ElasticsearchBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( bb241f...f9eb32 )

by Simonas

created 2016-12-13 13:57 UTC

MetadataCollector::getAnalysisNodeConfiguration() B

↳ Parent: MetadataCollector

Complexity

Conditions	6
Paths	4

Size

Total Lines	17
Code Lines	10

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	17
rs	8.8571
c	0
b	0
f	0
cc	6
eloc	10
nc	4
nop	4

<?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\Exception\DocumentParserException;
use ONGR\ElasticsearchBundle\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;

    /**
     * @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;
    }

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

    /**
     * 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 $name => $bundleConfig) {
            // Backward compatibility hack for support.
            if (!is_array($bundleConfig)) {
                $name = $bundleConfig;
                $bundleConfig = [];
            }
            $mappings = $this->getBundleMapping($name, $bundleConfig);

            $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
     * @param array $config Bundle configuration
     *
     * @return array Empty array on containing zero documents.
     */
    public function getBundleMapping($name, $config = [])
    {
        if (!is_string($name)) {
            throw new \LogicException('getBundleMapping() in the Metadata collector expects a string argument only!');
        }

        $cacheName =  'ongr.metadata.mapping.' . md5($name.serialize($config));

        $this->enableCache && $mappings = $this->cache->contains($cacheName);

        if (isset($mappings)) {
            return $mappings;
        }

        $mappings = [];
        $documentDir = isset($config['document_dir']) ? $config['document_dir'] : DocumentFinder::DOCUMENT_DIR;

        // Handle the case when single document mapping requested
        // Usage od ":" in name is deprecated. This if is only for BC.
        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, $documentDir);
            $bundle = $name;
        }

        $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 .
                '\\' . $documentDir .
                '\\' . $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->enableCache && $this->cache->save($cacheName, $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;
    }

    /**
     * Prepares analysis node for Elasticsearch client.
     *
     * @param array $bundles
     * @param array $analysisConfig
     *
     * @return array
     */
    public function getClientAnalysis(array $bundles, $analysisConfig = [])
    {
        $cacheName = 'ongr.metadata.analysis.'.md5(serialize($bundles));
        $this->enableCache && $typesAnalysis = $this->cache->fetch($cacheName);

        if (isset($typesAnalysis)) {
            return $typesAnalysis;
        }

        $typesAnalysis = [
            'analyzer' => [],
            'filter' => [],
            'tokenizer' => [],
            'char_filter' => [],
        ];

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

        foreach ($mappings as $type => $metadata) {
            foreach ($metadata['analyzers'] as $analyzerName) {
                if (isset($analysisConfig['analyzer'][$analyzerName])) {
                    $analyzer = $analysisConfig['analyzer'][$analyzerName];
                    $typesAnalysis['analyzer'][$analyzerName] = $analyzer;
                    $typesAnalysis['filter'] = $this->getAnalysisNodeConfiguration(
                        'filter',
                        $analyzer,
                        $analysisConfig,
                        $typesAnalysis['filter']
                    );
                    $typesAnalysis['tokenizer'] = $this->getAnalysisNodeConfiguration(
                        'tokenizer',
                        $analyzer,
                        $analysisConfig,
                        $typesAnalysis['tokenizer']
                    );
                    $typesAnalysis['char_filter'] = $this->getAnalysisNodeConfiguration(
                        'char_filter',
                        $analyzer,
                        $analysisConfig,
                        $typesAnalysis['char_filter']
                    );
                }
            }
        }

        $this->enableCache && $this->cache->save($cacheName, $mappings);

        return $typesAnalysis;
    }

    /**
     * Prepares analysis node content for Elasticsearch client.
     *
     * @param string $type Node type: filter, tokenizer or char_filter
     * @param array $analyzer Analyzer from which used helpers will be extracted.
     * @param array $analysisConfig Pre configured analyzers container
     * @param array $container Current analysis container where prepared helpers will be appended.
     *
     * @return array
     */
    private function getAnalysisNodeConfiguration($type, $analyzer, $analysisConfig, $container = [])
    {
        if (isset($analyzer[$type])) {
            if (is_array($analyzer[$type])) {
                foreach ($analyzer[$type] as $filter) {
                    if (isset($analysisConfig[$type][$filter])) {
                        $container[$filter] = $analysisConfig[$type][$filter];
                    }
                }
            } else {
                if (isset($analysisConfig[$type][$analyzer[$type]])) {
                    $container[$analyzer[$type]] = $analysisConfig[$type][$analyzer[$type]];
                }
            }
        }
        return $container;
    }

    /**
     * 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)
    {
        $cacheName = 'ongr.metadata.document.'.md5($namespace);

        $namespace = $this->getClassName($namespace);
        $this->enableCache && $mapping = $this->cache->fetch($cacheName);

        if (isset($mapping)) {
            return $mapping;
        }

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

        $this->enableCache && $this->cache->save($cacheName, $mapping);

        return $mapping;
    }

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


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\Exception\DocumentParserException;
16			use ONGR\ElasticsearchBundle\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			* @param DocumentFinder $finder For finding documents.
45			* @param DocumentParser $parser For reading document annotations.
46			* @param CacheProvider $cache Cache provider to store the meta data for later use.
47			*/
48			public function __construct($finder, $parser, $cache = null)
49			{
50			$this->finder = $finder;
51			$this->parser = $parser;
52			$this->cache = $cache;
53			}
54
55			/**
56			* Enables metadata caching.
57			*
58			* @param bool $enableCache
59			*/
60			public function setEnableCache($enableCache)
61			{
62			$this->enableCache = $enableCache;
63			}
64
65			/**
66			* Fetches bundles mapping from documents.
67			*
68			* @param string[] $bundles Elasticsearch manager config. You can get bundles list from 'mappings' node.
69			* @return array
70			*/
71			public function getMappings(array $bundles)
72			{
73			$output = [];
74			foreach ($bundles as $name => $bundleConfig) {
75			// Backward compatibility hack for support.
76			if (!is_array($bundleConfig)) {
77			$name = $bundleConfig;
78			$bundleConfig = [];
79			}
80			$mappings = $this->getBundleMapping($name, $bundleConfig);
81
82			$alreadyDefinedTypes = array_intersect_key($mappings, $output);
83			if (count($alreadyDefinedTypes)) {
84			throw new \LogicException(
85			implode(',', array_keys($alreadyDefinedTypes)) .
86			' type(s) already defined in other document, you can use the same ' .
87			'type only once in a manager definition.'
88			);
89			}
90
91			$output = array_merge($output, $mappings);
92			}
93
94			return $output;
95			}
96
97			/**
98			* Searches for documents in the bundle and tries to read them.
99			*
100			* @param string $name
101			* @param array $config Bundle configuration
102			*
103			* @return array Empty array on containing zero documents.
104			*/
105			public function getBundleMapping($name, $config = [])
106			{
107			if (!is_string($name)) {
108			throw new \LogicException('getBundleMapping() in the Metadata collector expects a string argument only!');
109			}
110
111			$cacheName = 'ongr.metadata.mapping.' . md5($name.serialize($config));
112
113			$this->enableCache && $mappings = $this->cache->contains($cacheName);
114
115			if (isset($mappings)) {
116			return $mappings;
117			}
118
119			$mappings = [];
120			$documentDir = isset($config['document_dir']) ? $config['document_dir'] : DocumentFinder::DOCUMENT_DIR;
121
122			// Handle the case when single document mapping requested
123			// Usage od ":" in name is deprecated. This if is only for BC.
124			if (strpos($name, ':') !== false) {
125			list($bundle, $documentClass) = explode(':', $name);
126			$documents = $this->finder->getBundleDocumentClasses($bundle);
127			$documents = in_array($documentClass, $documents) ? [$documentClass] : [];
128			} else {
129			$documents = $this->finder->getBundleDocumentClasses($name, $documentDir);
130			$bundle = $name;
131			}
132
133			$bundleNamespace = $this->finder->getBundleClass($bundle);
134			$bundleNamespace = substr($bundleNamespace, 0, strrpos($bundleNamespace, '\\'));
135
136			if (!count($documents)) {
137			return [];
138			}
139
140			// Loop through documents found in bundle.
141			foreach ($documents as $document) {
142			$documentReflection = new \ReflectionClass(
143			$bundleNamespace .
144			'\\' . $documentDir .
145			'\\' . $document
146			);
147
148			try {
149			$documentMapping = $this->getDocumentReflectionMapping($documentReflection);
150			} catch (MissingDocumentAnnotationException $exception) {
151			// Not a document, just ignore
152			continue;
153			}
154
155			if (!array_key_exists($documentMapping['type'], $mappings)) {
156			$documentMapping['bundle'] = $bundle;
157			$mappings = array_merge($mappings, [$documentMapping['type'] => $documentMapping]);
158			} else {
159			throw new \LogicException(
160			$bundle . ' has 2 same type names defined in the documents. ' .
161			'Type names must be unique!'
162			);
163			}
164			}
165
166			$this->enableCache && $this->cache->save($cacheName, $mappings);
167
168			return $mappings;
169			}
170
171			/**
172			* @param array $manager
173			*
174			* @return array
175			*/
176			public function getManagerTypes($manager)
177			{
178			$mapping = $this->getMappings($manager['mappings']);
179
180			return array_keys($mapping);
181			}
182
183			/**
184			* Resolves Elasticsearch type by document class.
185			*
186			* @param string $className FQCN or string in AppBundle:Document format
187			*
188			* @return string
189			*/
190			public function getDocumentType($className)
191			{
192			$mapping = $this->getMapping($className);
193
194			return $mapping['type'];
195			}
196
197			/**
198			* Retrieves prepared mapping to sent to the elasticsearch client.
199			*
200			* @param array $bundles Manager config.
201			*
202			* @return array\|null
203			*/
204			public function getClientMapping(array $bundles)
205			{
206			/** @var array $typesMapping Array of filtered mappings for the elasticsearch client*/
207			$typesMapping = null;
208
209			/** @var array $mappings All mapping info */
210			$mappings = $this->getMappings($bundles);
211
212			foreach ($mappings as $type => $mapping) {
213			if (!empty($mapping['properties'])) {
214			$typesMapping[$type] = array_filter(
215			array_merge(
216			['properties' => $mapping['properties']],
217			$mapping['fields']
218			),
219			function ($value) {
220			return (bool)$value \|\| is_bool($value);
221			}
222			);
223			}
224			}
225
226			return $typesMapping;
227			}
228
229			/**
230			* Prepares analysis node for Elasticsearch client.
231			*
232			* @param array $bundles
233			* @param array $analysisConfig
234			*
235			* @return array
236			*/
237			public function getClientAnalysis(array $bundles, $analysisConfig = [])
238			{
239			$cacheName = 'ongr.metadata.analysis.'.md5(serialize($bundles));
240			$this->enableCache && $typesAnalysis = $this->cache->fetch($cacheName);
241
242			if (isset($typesAnalysis)) {
243			return $typesAnalysis;
244			}
245
246			$typesAnalysis = [
247			'analyzer' => [],
248			'filter' => [],
249			'tokenizer' => [],
250			'char_filter' => [],
251			];
252
253			/** @var array $mappings All mapping info */
254			$mappings = $this->getMappings($bundles);
255
256			foreach ($mappings as $type => $metadata) {
257			foreach ($metadata['analyzers'] as $analyzerName) {
258			if (isset($analysisConfig['analyzer'][$analyzerName])) {
259			$analyzer = $analysisConfig['analyzer'][$analyzerName];
260			$typesAnalysis['analyzer'][$analyzerName] = $analyzer;
261			$typesAnalysis['filter'] = $this->getAnalysisNodeConfiguration(
262			'filter',
263			$analyzer,
264			$analysisConfig,
265			$typesAnalysis['filter']
266			);
267			$typesAnalysis['tokenizer'] = $this->getAnalysisNodeConfiguration(
268			'tokenizer',
269			$analyzer,
270			$analysisConfig,
271			$typesAnalysis['tokenizer']
272			);
273			$typesAnalysis['char_filter'] = $this->getAnalysisNodeConfiguration(
274			'char_filter',
275			$analyzer,
276			$analysisConfig,
277			$typesAnalysis['char_filter']
278			);
279			}
280			}
281			}
282
283			$this->enableCache && $this->cache->save($cacheName, $mappings);
284
285			return $typesAnalysis;
286			}
287
288			/**
289			* Prepares analysis node content for Elasticsearch client.
290			*
291			* @param string $type Node type: filter, tokenizer or char_filter
292			* @param array $analyzer Analyzer from which used helpers will be extracted.
293			* @param array $analysisConfig Pre configured analyzers container
294			* @param array $container Current analysis container where prepared helpers will be appended.
295			*
296			* @return array
297			*/
298			private function getAnalysisNodeConfiguration($type, $analyzer, $analysisConfig, $container = [])
299			{
300			if (isset($analyzer[$type])) {
301			if (is_array($analyzer[$type])) {
302			foreach ($analyzer[$type] as $filter) {
303			if (isset($analysisConfig[$type][$filter])) {
304			$container[$filter] = $analysisConfig[$type][$filter];
305			}
306			}
307			} else {
308			if (isset($analysisConfig[$type][$analyzer[$type]])) {
309			$container[$analyzer[$type]] = $analysisConfig[$type][$analyzer[$type]];
310			}
311			}
312			}
313			return $container;
314			}
315
316			/**
317			* Gathers annotation data from class.
318			*
319			* @param \ReflectionClass $reflectionClass Document reflection class to read mapping from.
320			*
321			* @return array
322			* @throws DocumentParserException
323			*/
324			private function getDocumentReflectionMapping(\ReflectionClass $reflectionClass)
325			{
326			return $this->parser->parse($reflectionClass);
327			}
328
329			/**
330			* Returns single document mapping metadata.
331			*
332			* @param string $namespace Document namespace
333			*
334			* @return array
335			* @throws DocumentParserException
336			*/
337			public function getMapping($namespace)
338			{
339			$cacheName = 'ongr.metadata.document.'.md5($namespace);
340
341			$namespace = $this->getClassName($namespace);
342			$this->enableCache && $mapping = $this->cache->fetch($cacheName);
343
344			if (isset($mapping)) {
345			return $mapping;
346			}
347
348			$mapping = $this->getDocumentReflectionMapping(new \ReflectionClass($namespace));
349
350			$this->enableCache && $this->cache->save($cacheName, $mapping);
351
352			return $mapping;
353			}
354
355			/**
356			* Returns fully qualified class name.
357			*
358			* @param string $className
359			*
360			* @return string
361			*/
362			public function getClassName($className)
363			{
364			return $this->finder->getNamespace($className);
365			}
366			}
367

ongr-io / ElasticsearchBundle

Push — master ( bb241f...f9eb32 )

MetadataCollector::getAnalysisNodeConfiguration() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like