DocumentParser::__construct() - Code Metrics - Inspection of "Serialization makeover" - ongr-io/ElasticsearchBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — 6.1-dev (#889)

unknown

created 2019-10-24 06:03 UTC

DocumentParser::__construct() A

↳ Parent: DocumentParser

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	9
rs	9.9666
c	0
b	0
f	0
cc	1
nc	1
nop	3

<?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\Annotations\AnnotationRegistry;
use Doctrine\Common\Annotations\Reader;
use Doctrine\Common\Cache\Cache;
use ONGR\ElasticsearchBundle\Annotation\AbstractAnnotation;
use ONGR\ElasticsearchBundle\Annotation\Embedded;
use ONGR\ElasticsearchBundle\Annotation\Id;
use ONGR\ElasticsearchBundle\Annotation\Index;
use ONGR\ElasticsearchBundle\Annotation\NestedType;
use ONGR\ElasticsearchBundle\Annotation\ObjectType;
use ONGR\ElasticsearchBundle\Annotation\PropertiesAwareInterface;
use ONGR\ElasticsearchBundle\Annotation\Property;
use ONGR\ElasticsearchBundle\DependencyInjection\Configuration;

/**
 * Document parser used for reading document annotations.
 */
class DocumentParser
{
    const OBJ_CACHED_FIELDS = 'ongr.obj_fields';
    const EMBEDDED_CACHED_FIELDS = 'ongr.embedded_fields';
    const ARRAY_CACHED_FIELDS = 'ongr.array_fields';

    private $reader;
    private $properties = [];
    private $analysisConfig = [];
    private $cache;

    public function __construct(Reader $reader, Cache $cache, array $analysisConfig = [])
    {
        $this->reader = $reader;
        $this->cache = $cache;
        $this->analysisConfig = $analysisConfig;

        #Fix for annotations loader until doctrine/annotations 2.0 will be released with the full autoload support.
        AnnotationRegistry::registerLoader('class_exists');

    }

    public function getIndexAliasName(\ReflectionClass $class): string
    {
        /** @var Index $document */
        $document = $this->reader->getClassAnnotation($class, Index::class);

        return $document->alias ?? Caser::snake($class->getShortName());
    }

    public function isDefaultIndex(\ReflectionClass $class): bool
    {
        /** @var Index $document */
        $document = $this->reader->getClassAnnotation($class, Index::class);

        return $document->default;
    }

    public function getIndexAnnotation(\ReflectionClass $class)
    {
        /** @var Index $document */
        $document = $this->reader->getClassAnnotation($class, Index::class);

        return $document;
    }

    /**
     * @deprecated will be deleted in v7. Types are deleted from elasticsearch.
     */
    public function getTypeName(\ReflectionClass $class): string
    {
        /** @var Index $document */
        $document = $this->reader->getClassAnnotation($class, Index::class);

        return $document->typeName ?? '_doc';

    }

    public function getIndexMetadata(\ReflectionClass $class): array
    {
        if ($class->isTrait()) {
            return [];
        }

        /** @var Index $document */
        $document = $this->reader->getClassAnnotation($class, Index::class);

        if ($document === null) {
            return [];
        }

        $settings = $document->getSettings();
        $settings['analysis'] = $this->getAnalysisConfig($class);

        return array_filter(array_map('array_filter', [
            'settings' => $settings,
            'mappings' => [
                $this->getTypeName($class) => [

                    'properties' => array_filter($this->getClassMetadata($class))
                ]
            ]
        ]));
    }

    public function getDocumentNamespace(string $indexAlias): ?string
    {
        if ($this->cache->contains(Configuration::ONGR_INDEXES)) {
            $indexes = $this->cache->fetch(Configuration::ONGR_INDEXES);

            if (isset($indexes[$indexAlias])) {
                return $indexes[$indexAlias];
            }
        }

        return null;
    }

    public function getParsedDocument(\ReflectionClass $class): Index
    {
        /** @var Index $document */
        $document = $this->reader->getClassAnnotation($class, Index::class);

        return $document;
    }

    private function getClassMetadata(\ReflectionClass $class): array
    {
        $mapping = [];
        $objFields = null;
        $arrayFields = null;
        $embeddedFields = null;

        /** @var \ReflectionProperty $property */
        foreach ($this->getDocumentPropertiesReflection($class) as $name => $property) {
            $annotations = $this->reader->getPropertyAnnotations($property);

            /** @var AbstractAnnotation $annotation */
            foreach ($annotations as $annotation) {
                if (!$annotation instanceof PropertiesAwareInterface) {
                    continue;
                }

                $fieldMapping = $annotation->getSettings();

                if ($annotation instanceof Property) {
                    $fieldMapping['type'] = $annotation->type;
                    $fieldMapping['analyzer'] = $annotation->analyzer;
                    $fieldMapping['search_analyzer'] = $annotation->searchAnalyzer;
                    $fieldMapping['search_quote_analyzer'] = $annotation->searchQuoteAnalyzer;
                }

                if ($annotation instanceof Embedded) {
                    $embeddedClass = new \ReflectionClass($annotation->class);
                    $fieldMapping['type'] = $this->getObjectMappingType($embeddedClass);
                    $fieldMapping['properties'] = $this->getClassMetadata($embeddedClass);
                    $embeddedFields[$name] = $annotation->class;
                }

                $mapping[$annotation->getName() ?? Caser::snake($name)] = array_filter($fieldMapping);
                $objFields[$name] = $annotation->getName() ?? Caser::snake($name);
                $arrayFields[$annotation->getName() ?? Caser::snake($name)] = $name;
            }
        }

        //Embeded fields are option compared to the array or object mapping.
        if ($embeddedFields) {
            $cacheItem = $this->cache->fetch(self::EMBEDDED_CACHED_FIELDS) ?? [];
            $cacheItem[$class->getName()] = $embeddedFields;
            $t = $this->cache->save(self::EMBEDDED_CACHED_FIELDS, $cacheItem);
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        }

        $cacheItem = $this->cache->fetch(self::ARRAY_CACHED_FIELDS) ?? [];
        $cacheItem[$class->getName()] = $arrayFields;
        $this->cache->save(self::ARRAY_CACHED_FIELDS, $cacheItem);

        $cacheItem = $this->cache->fetch(self::OBJ_CACHED_FIELDS) ?? [];
        $cacheItem[$class->getName()] = $objFields;
        $this->cache->save(self::OBJ_CACHED_FIELDS, $cacheItem);

        return $mapping;
    }

    public function getPropertyMetadata(\ReflectionClass $class, bool $subClass = false): array
    {
        if ($class->isTrait() || (!$this->reader->getClassAnnotation($class, Index::class) && !$subClass)) {
            return [];
        }

        $metadata = [];

        /** @var \ReflectionProperty $property */
        foreach ($this->getDocumentPropertiesReflection($class) as $name => $property) {
            /** @var AbstractAnnotation $annotation */
            foreach ($this->reader->getPropertyAnnotations($property) as $annotation) {
                if (!$annotation instanceof PropertiesAwareInterface) {
                    continue;
                }

                $propertyMetadata = [
                    'identifier' => false,
                    'class' => null,
                    'embeded' => false,
                    'public' => $property->isPublic(),
                    'getter' => null,
                    'setter' => null,
                    'sub_properties' => []
                ];

                $name = $property->getName();
                $propertyMetadata['name'] = $name;

                if (!$propertyMetadata['public']) {
                    $propertyMetadata['getter'] = $this->guessGetter($class, $name);
                }

                $fieldMapping = $annotation->getSettings();
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}

                if ($annotation instanceof Id) {
                    $propertyMetadata['identifier'] = true;
                } else {
                    if (!$propertyMetadata['public']) {
                        $propertyMetadata['setter'] = $this->guessSetter($class, $name);
                    }
                }

                if ($annotation instanceof Embedded) {
                    $propertyMetadata['embeded'] = true;
                    $propertyMetadata['class'] = $annotation->class;
                    $propertyMetadata['sub_properties'] = $this->getPropertyMetadata(
                        new \ReflectionClass($annotation->class),
                        true
                    );
                }

                $metadata[$annotation->getName() ?? Caser::snake($name)] = $propertyMetadata;
            }
        }

        return $metadata;
    }

    public function getAnalysisConfig(\ReflectionClass $class): array
    {
        $config = [];
        $mapping = $this->getClassMetadata($class);

        //Think how to remove these array merge
        $analyzers = $this->getListFromArrayByKey('analyzer', $mapping);
        $analyzers = array_merge($analyzers, $this->getListFromArrayByKey('search_analyzer', $mapping));
        $analyzers = array_merge($analyzers, $this->getListFromArrayByKey('search_quote_analyzer', $mapping));

        foreach ($analyzers as $analyzer) {
            if (isset($this->analysisConfig['analyzer'][$analyzer])) {
                $config['analyzer'][$analyzer] = $this->analysisConfig['analyzer'][$analyzer];
            }
        }

        foreach (['tokenizer', 'filter', 'normalizer', 'char_filter'] as $type) {
            $list = $this->getListFromArrayByKey($type, $config);

            foreach ($list as $listItem) {
                if (isset($this->analysisConfig[$type][$listItem])) {
                    $config[$type][$listItem] = $this->analysisConfig[$type][$listItem];
                }
            }
        }

        return $config;
    }

    protected function guessGetter(\ReflectionClass $class, $name): string
    {
        if ($class->hasMethod($name)) {
            return $name;
        }

        if ($class->hasMethod('get' . ucfirst($name))) {
            return 'get' . ucfirst($name);
        }

        if ($class->hasMethod('is' . ucfirst($name))) {
            return 'is' . ucfirst($name);
        }

        throw new \Exception("Could not determine a getter for `$name` of class `{$class->getNamespaceName()}`");
    }

    protected function guessSetter(\ReflectionClass $class, $name): string
    {
        if ($class->hasMethod('set' . ucfirst($name))) {
            return 'set' . ucfirst($name);
        }

        throw new \Exception("Could not determine a setter for `$name` of class `{$class->getNamespaceName()}`");
    }

    private function getListFromArrayByKey(string $searchKey, array $array): array
    {
        $list = [];

        foreach (new \RecursiveIteratorIterator(
            new \RecursiveArrayIterator($array),
            \RecursiveIteratorIterator::SELF_FIRST
        ) as $key => $value) {
            if ($key === $searchKey) {
                if (is_array($value)) {
                    $list = array_merge($list, $value);
                } else {
                    $list[] = $value;
                }
            }
        }

        return array_unique($list);
    }

    private function getObjectMappingType(\ReflectionClass $class): string
    {
        switch (true) {
            case $this->reader->getClassAnnotation($class, ObjectType::class):
                $type = ObjectType::TYPE;
                break;
            case $this->reader->getClassAnnotation($class, NestedType::class):
                $type = NestedType::TYPE;
                break;
            default:
                throw new \LogicException(
                    sprintf(
                        '%s must be used @ObjectType or @NestedType as embeddable object.',
                        $class->getName()
                    )
                );
        }

        return $type;
    }

    private function getDocumentPropertiesReflection(\ReflectionClass $class): array
    {
        if (in_array($class->getName(), $this->properties)) {
            return $this->properties[$class->getName()];
        }

        $properties = [];

        foreach ($class->getProperties() as $property) {
            if (!in_array($property->getName(), $properties)) {
                $properties[$property->getName()] = $property;
            }
        }

        $parentReflection = $class->getParentClass();
        if ($parentReflection !== false) {
            $properties = array_merge(
                $properties,
                array_diff_key($this->getDocumentPropertiesReflection($parentReflection), $properties)
            );
        }

        $this->properties[$class->getName()] = $properties;

        return $properties;
    }
}


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\Annotations\AnnotationRegistry;
15			use Doctrine\Common\Annotations\Reader;
16			use Doctrine\Common\Cache\Cache;
17			use ONGR\ElasticsearchBundle\Annotation\AbstractAnnotation;
18			use ONGR\ElasticsearchBundle\Annotation\Embedded;
19			use ONGR\ElasticsearchBundle\Annotation\Id;
20			use ONGR\ElasticsearchBundle\Annotation\Index;
21			use ONGR\ElasticsearchBundle\Annotation\NestedType;
22			use ONGR\ElasticsearchBundle\Annotation\ObjectType;
23			use ONGR\ElasticsearchBundle\Annotation\PropertiesAwareInterface;
24			use ONGR\ElasticsearchBundle\Annotation\Property;
25			use ONGR\ElasticsearchBundle\DependencyInjection\Configuration;
26
27			/**
28			* Document parser used for reading document annotations.
29			*/
30			class DocumentParser
31			{
32			const OBJ_CACHED_FIELDS = 'ongr.obj_fields';
33			const EMBEDDED_CACHED_FIELDS = 'ongr.embedded_fields';
34			const ARRAY_CACHED_FIELDS = 'ongr.array_fields';
35
36			private $reader;
37			private $properties = [];
38			private $analysisConfig = [];
39			private $cache;
40
41			public function __construct(Reader $reader, Cache $cache, array $analysisConfig = [])
42			{
43			$this->reader = $reader;
44			$this->cache = $cache;
45			$this->analysisConfig = $analysisConfig;
46
47			#Fix for annotations loader until doctrine/annotations 2.0 will be released with the full autoload support.
48			AnnotationRegistry::registerLoader('class_exists');
			0 ignored issues – show Deprecated Code introduced 2019-03-18 22:16 UTC by Report Bug Copy Issue Report The method `Doctrine\Common\Annotati...istry::registerLoader()` has been deprecated with message: this method is deprecated and will be removed in doctrine/annotations 2.0 autoloading should be deferred to the globally registered autoloader by then. For now, use @example AnnotationRegistry::registerLoader('class_exists') This method has been deprecated. The supplier of the class has supplied an explanatory message. The explanatory message should give you some clue as to whether and when the method will be removed from the class and what other method or class to use instead. Loading history...
49			}
50
51			public function getIndexAliasName(\ReflectionClass $class): string
52			{
53			/** @var Index $document */
54			$document = $this->reader->getClassAnnotation($class, Index::class);
55
56			return $document->alias ?? Caser::snake($class->getShortName());
57			}
58
59			public function isDefaultIndex(\ReflectionClass $class): bool
60			{
61			/** @var Index $document */
62			$document = $this->reader->getClassAnnotation($class, Index::class);
63
64			return $document->default;
65			}
66
67			public function getIndexAnnotation(\ReflectionClass $class)
68			{
69			/** @var Index $document */
70			$document = $this->reader->getClassAnnotation($class, Index::class);
71
72			return $document;
73			}
74
75			/**
76			* @deprecated will be deleted in v7. Types are deleted from elasticsearch.
77			*/
78			public function getTypeName(\ReflectionClass $class): string
79			{
80			/** @var Index $document */
81			$document = $this->reader->getClassAnnotation($class, Index::class);
82
83			return $document->typeName ?? '_doc';
			0 ignored issues – show Deprecated Code introduced 2019-03-18 22:16 UTC by Report Bug Copy Issue Report The property `ONGR\ElasticsearchBundle...tation\Index::$typeName` has been deprecated with message: will be removed in v7 since there will be no more types in the indexes. This property has been deprecated. The supplier of the class has supplied an explanatory message. The explanatory message should give you some clue as to whether and when the property will be removed from the class and what other property to use instead. Loading history...
84			}
85
86			public function getIndexMetadata(\ReflectionClass $class): array
87			{
88			if ($class->isTrait()) {
89			return [];
90			}
91
92			/** @var Index $document */
93			$document = $this->reader->getClassAnnotation($class, Index::class);
94
95			if ($document === null) {
96			return [];
97			}
98
99			$settings = $document->getSettings();
100			$settings['analysis'] = $this->getAnalysisConfig($class);
101
102			return array_filter(array_map('array_filter', [
103			'settings' => $settings,
104			'mappings' => [
105			$this->getTypeName($class) => [
			0 ignored issues – show Deprecated Code introduced 2019-03-18 22:16 UTC by Report Bug Copy Issue Report The method `ONGR\ElasticsearchBundle...ntParser::getTypeName()` has been deprecated with message: will be deleted in v7. Types are deleted from elasticsearch. This method has been deprecated. The supplier of the class has supplied an explanatory message. The explanatory message should give you some clue as to whether and when the method will be removed from the class and what other method or class to use instead. Loading history...
106			'properties' => array_filter($this->getClassMetadata($class))
107			]
108			]
109			]));
110			}
111
112			public function getDocumentNamespace(string $indexAlias): ?string
113			{
114			if ($this->cache->contains(Configuration::ONGR_INDEXES)) {
115			$indexes = $this->cache->fetch(Configuration::ONGR_INDEXES);
116
117			if (isset($indexes[$indexAlias])) {
118			return $indexes[$indexAlias];
119			}
120			}
121
122			return null;
123			}
124
125			public function getParsedDocument(\ReflectionClass $class): Index
126			{
127			/** @var Index $document */
128			$document = $this->reader->getClassAnnotation($class, Index::class);
129
130			return $document;
131			}
132
133			private function getClassMetadata(\ReflectionClass $class): array
134			{
135			$mapping = [];
136			$objFields = null;
137			$arrayFields = null;
138			$embeddedFields = null;
139
140			/** @var \ReflectionProperty $property */
141			foreach ($this->getDocumentPropertiesReflection($class) as $name => $property) {
142			$annotations = $this->reader->getPropertyAnnotations($property);
143
144			/** @var AbstractAnnotation $annotation */
145			foreach ($annotations as $annotation) {
146			if (!$annotation instanceof PropertiesAwareInterface) {
147			continue;
148			}
149
150			$fieldMapping = $annotation->getSettings();
151
152			if ($annotation instanceof Property) {
153			$fieldMapping['type'] = $annotation->type;
154			$fieldMapping['analyzer'] = $annotation->analyzer;
155			$fieldMapping['search_analyzer'] = $annotation->searchAnalyzer;
156			$fieldMapping['search_quote_analyzer'] = $annotation->searchQuoteAnalyzer;
157			}
158
159			if ($annotation instanceof Embedded) {
160			$embeddedClass = new \ReflectionClass($annotation->class);
161			$fieldMapping['type'] = $this->getObjectMappingType($embeddedClass);
162			$fieldMapping['properties'] = $this->getClassMetadata($embeddedClass);
163			$embeddedFields[$name] = $annotation->class;
164			}
165
166			$mapping[$annotation->getName() ?? Caser::snake($name)] = array_filter($fieldMapping);
167			$objFields[$name] = $annotation->getName() ?? Caser::snake($name);
168			$arrayFields[$annotation->getName() ?? Caser::snake($name)] = $name;
169			}
170			}
171
172			//Embeded fields are option compared to the array or object mapping.
173			if ($embeddedFields) {
174			$cacheItem = $this->cache->fetch(self::EMBEDDED_CACHED_FIELDS) ?? [];
175			$cacheItem[$class->getName()] = $embeddedFields;
176			$t = $this->cache->save(self::EMBEDDED_CACHED_FIELDS, $cacheItem);
			0 ignored issues – show Unused Code introduced 2019-03-18 22:16 UTC by Report Bug Copy Issue Report `$t` is not used, you could remove the assignment. This check looks for variable assignements that are either overwritten by other assignments or where the variable is not used subsequently. $myVar = 'Value'; $higher = false; if (rand(1, 6) > 3) { $higher = true; } else { $higher = false; } Both the `$myVar` assignment in line 1 and the `$higher` assignment in line 2 are dead. The first because `$myVar` is never used and the second because `$higher` is always overwritten for every possible time line. Loading history...
177			}
178
179			$cacheItem = $this->cache->fetch(self::ARRAY_CACHED_FIELDS) ?? [];
180			$cacheItem[$class->getName()] = $arrayFields;
181			$this->cache->save(self::ARRAY_CACHED_FIELDS, $cacheItem);
182
183			$cacheItem = $this->cache->fetch(self::OBJ_CACHED_FIELDS) ?? [];
184			$cacheItem[$class->getName()] = $objFields;
185			$this->cache->save(self::OBJ_CACHED_FIELDS, $cacheItem);
186
187			return $mapping;
188			}
189
190			public function getPropertyMetadata(\ReflectionClass $class, bool $subClass = false): array
191			{
192			if ($class->isTrait() \|\| (!$this->reader->getClassAnnotation($class, Index::class) && !$subClass)) {
193			return [];
194			}
195
196			$metadata = [];
197
198			/** @var \ReflectionProperty $property */
199			foreach ($this->getDocumentPropertiesReflection($class) as $name => $property) {
200			/** @var AbstractAnnotation $annotation */
201			foreach ($this->reader->getPropertyAnnotations($property) as $annotation) {
202			if (!$annotation instanceof PropertiesAwareInterface) {
203			continue;
204			}
205
206			$propertyMetadata = [
207			'identifier' => false,
208			'class' => null,
209			'embeded' => false,
210			'public' => $property->isPublic(),
211			'getter' => null,
212			'setter' => null,
213			'sub_properties' => []
214			];
215
216			$name = $property->getName();
217			$propertyMetadata['name'] = $name;
218
219			if (!$propertyMetadata['public']) {
220			$propertyMetadata['getter'] = $this->guessGetter($class, $name);
221			}
222
223			$fieldMapping = $annotation->getSettings();
			0 ignored issues – show Unused Code introduced 2019-10-23 21:39 UTC by Report Bug Copy Issue Report `$fieldMapping` is not used, you could remove the assignment. This check looks for variable assignements that are either overwritten by other assignments or where the variable is not used subsequently. $myVar = 'Value'; $higher = false; if (rand(1, 6) > 3) { $higher = true; } else { $higher = false; } Both the `$myVar` assignment in line 1 and the `$higher` assignment in line 2 are dead. The first because `$myVar` is never used and the second because `$higher` is always overwritten for every possible time line. Loading history...
224
225			if ($annotation instanceof Id) {
226			$propertyMetadata['identifier'] = true;
227			} else {
228			if (!$propertyMetadata['public']) {
229			$propertyMetadata['setter'] = $this->guessSetter($class, $name);
230			}
231			}
232
233			if ($annotation instanceof Embedded) {
234			$propertyMetadata['embeded'] = true;
235			$propertyMetadata['class'] = $annotation->class;
236			$propertyMetadata['sub_properties'] = $this->getPropertyMetadata(
237			new \ReflectionClass($annotation->class),
238			true
239			);
240			}
241
242			$metadata[$annotation->getName() ?? Caser::snake($name)] = $propertyMetadata;
243			}
244			}
245
246			return $metadata;
247			}
248
249			public function getAnalysisConfig(\ReflectionClass $class): array
250			{
251			$config = [];
252			$mapping = $this->getClassMetadata($class);
253
254			//Think how to remove these array merge
255			$analyzers = $this->getListFromArrayByKey('analyzer', $mapping);
256			$analyzers = array_merge($analyzers, $this->getListFromArrayByKey('search_analyzer', $mapping));
257			$analyzers = array_merge($analyzers, $this->getListFromArrayByKey('search_quote_analyzer', $mapping));
258
259			foreach ($analyzers as $analyzer) {
260			if (isset($this->analysisConfig['analyzer'][$analyzer])) {
261			$config['analyzer'][$analyzer] = $this->analysisConfig['analyzer'][$analyzer];
262			}
263			}
264
265			foreach (['tokenizer', 'filter', 'normalizer', 'char_filter'] as $type) {
266			$list = $this->getListFromArrayByKey($type, $config);
267
268			foreach ($list as $listItem) {
269			if (isset($this->analysisConfig[$type][$listItem])) {
270			$config[$type][$listItem] = $this->analysisConfig[$type][$listItem];
271			}
272			}
273			}
274
275			return $config;
276			}
277
278			protected function guessGetter(\ReflectionClass $class, $name): string
279			{
280			if ($class->hasMethod($name)) {
281			return $name;
282			}
283
284			if ($class->hasMethod('get' . ucfirst($name))) {
285			return 'get' . ucfirst($name);
286			}
287
288			if ($class->hasMethod('is' . ucfirst($name))) {
289			return 'is' . ucfirst($name);
290			}
291
292			throw new \Exception("Could not determine a getter for `$name` of class `{$class->getNamespaceName()}`");
293			}
294
295			protected function guessSetter(\ReflectionClass $class, $name): string
296			{
297			if ($class->hasMethod('set' . ucfirst($name))) {
298			return 'set' . ucfirst($name);
299			}
300
301			throw new \Exception("Could not determine a setter for `$name` of class `{$class->getNamespaceName()}`");
302			}
303
304			private function getListFromArrayByKey(string $searchKey, array $array): array
305			{
306			$list = [];
307
308			foreach (new \RecursiveIteratorIterator(
309			new \RecursiveArrayIterator($array),
310			\RecursiveIteratorIterator::SELF_FIRST
311			) as $key => $value) {
312			if ($key === $searchKey) {
313			if (is_array($value)) {
314			$list = array_merge($list, $value);
315			} else {
316			$list[] = $value;
317			}
318			}
319			}
320
321			return array_unique($list);
322			}
323
324			private function getObjectMappingType(\ReflectionClass $class): string
325			{
326			switch (true) {
327			case $this->reader->getClassAnnotation($class, ObjectType::class):
328			$type = ObjectType::TYPE;
329			break;
330			case $this->reader->getClassAnnotation($class, NestedType::class):
331			$type = NestedType::TYPE;
332			break;
333			default:
334			throw new \LogicException(
335			sprintf(
336			'%s must be used @ObjectType or @NestedType as embeddable object.',
337			$class->getName()
338			)
339			);
340			}
341
342			return $type;
343			}
344
345			private function getDocumentPropertiesReflection(\ReflectionClass $class): array
346			{
347			if (in_array($class->getName(), $this->properties)) {
348			return $this->properties[$class->getName()];
349			}
350
351			$properties = [];
352
353			foreach ($class->getProperties() as $property) {
354			if (!in_array($property->getName(), $properties)) {
355			$properties[$property->getName()] = $property;
356			}
357			}
358
359			$parentReflection = $class->getParentClass();
360			if ($parentReflection !== false) {
361			$properties = array_merge(
362			$properties,
363			array_diff_key($this->getDocumentPropertiesReflection($parentReflection), $properties)
364			);
365			}
366
367			$this->properties[$class->getName()] = $properties;
368
369			return $properties;
370			}
371			}
372

ongr-io / ElasticsearchBundle

Pull Request — 6.1-dev (#889)

DocumentParser::__construct() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like