AnnotationDriver::loadMetadataForClass() - Code Metrics - Inspection of "[WIP] 2.0" - schmittjoh/serializer - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#743)

by Asmir

created 2018-02-17 19:27 UTC

AnnotationDriver::loadMetadataForClass() F

↳ Parent: AnnotationDriver

Complexity

Conditions	59
Paths	672

Size

Total Lines	176
Code Lines	142

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	137
CRAP Score	59.0341

Importance

Changes

Metric	Value
dl	0
loc	176
ccs	137
cts	140
cp	0.9786
rs	2
c	0
b	0
f	0
cc	59
eloc	142
nc	672
nop	1
crap	59.0341

How to fix Long Method Complexity

<?php

/*
 * Copyright 2016 Johannes M. Schmitt <[email protected]>
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

namespace JMS\Serializer\Metadata\Driver;

use Doctrine\Common\Annotations\Reader;
use JMS\Parser\AbstractParser;
use JMS\Serializer\Annotation\Accessor;
use JMS\Serializer\Annotation\AccessorOrder;
use JMS\Serializer\Annotation\AccessType;
use JMS\Serializer\Annotation\Discriminator;
use JMS\Serializer\Annotation\Exclude;
use JMS\Serializer\Annotation\ExcludeIf;
use JMS\Serializer\Annotation\ExclusionPolicy;
use JMS\Serializer\Annotation\Expose;
use JMS\Serializer\Annotation\Groups;
use JMS\Serializer\Annotation\Inline;
use JMS\Serializer\Annotation\MaxDepth;
use JMS\Serializer\Annotation\PostDeserialize;
use JMS\Serializer\Annotation\PostSerialize;
use JMS\Serializer\Annotation\PreSerialize;
use JMS\Serializer\Annotation\ReadOnly;
use JMS\Serializer\Annotation\SerializedName;
use JMS\Serializer\Annotation\Since;
use JMS\Serializer\Annotation\SkipWhenEmpty;
use JMS\Serializer\Annotation\Type;
use JMS\Serializer\Annotation\Until;
use JMS\Serializer\Annotation\VirtualProperty;
use JMS\Serializer\Annotation\XmlAttribute;
use JMS\Serializer\Annotation\XmlAttributeMap;
use JMS\Serializer\Annotation\XmlDiscriminator;
use JMS\Serializer\Annotation\XmlElement;
use JMS\Serializer\Annotation\XmlKeyValuePairs;
use JMS\Serializer\Annotation\XmlList;
use JMS\Serializer\Annotation\XmlMap;
use JMS\Serializer\Annotation\XmlNamespace;
use JMS\Serializer\Annotation\XmlRoot;
use JMS\Serializer\Annotation\XmlValue;
use JMS\Serializer\Exception\InvalidArgumentException;
use JMS\Serializer\Metadata\ClassMetadata;
use JMS\Serializer\Metadata\ExpressionPropertyMetadata;
use JMS\Serializer\Metadata\PropertyMetadata;
use JMS\Serializer\Metadata\VirtualPropertyMetadata;
use JMS\Serializer\TypeParser;
use Metadata\Driver\DriverInterface;
use Metadata\MethodMetadata;

class AnnotationDriver implements DriverInterface
{
    private $reader;
    private $typeParser;

    public function __construct(Reader $reader, AbstractParser $typeParser = null)
    {
        $this->reader = $reader;
        $this->typeParser = $typeParser ?: new TypeParser();
    }

    public function loadMetadataForClass(\ReflectionClass $class)
    {
        $classMetadata = new ClassMetadata($name = $class->name);
        $classMetadata->fileResources[] = $class->getFilename();

        $propertiesMetadata = array();
        $propertiesAnnotations = array();

        $exclusionPolicy = 'NONE';
        $excludeAll = false;
        $classAccessType = PropertyMetadata::ACCESS_TYPE_PROPERTY;
        $readOnlyClass = false;
        foreach ($this->reader->getClassAnnotations($class) as $annot) {
            if ($annot instanceof ExclusionPolicy) {
                $exclusionPolicy = $annot->policy;
            } elseif ($annot instanceof XmlRoot) {
                $classMetadata->xmlRootName = $annot->name;
                $classMetadata->xmlRootNamespace = $annot->namespace;
            } elseif ($annot instanceof XmlNamespace) {
                $classMetadata->registerNamespace($annot->uri, $annot->prefix);
            } elseif ($annot instanceof Exclude) {
                $excludeAll = true;
            } elseif ($annot instanceof AccessType) {
                $classAccessType = $annot->type;
            } elseif ($annot instanceof ReadOnly) {
                $readOnlyClass = true;
            } elseif ($annot instanceof AccessorOrder) {
                $classMetadata->setAccessorOrder($annot->order, $annot->custom);
            } elseif ($annot instanceof Discriminator) {
                if ($annot->disabled) {
                    $classMetadata->discriminatorDisabled = true;
                } else {
                    $classMetadata->setDiscriminator($annot->field, $annot->map, $annot->groups);
                }
            } elseif ($annot instanceof XmlDiscriminator) {
                $classMetadata->xmlDiscriminatorAttribute = (bool)$annot->attribute;
                $classMetadata->xmlDiscriminatorCData = (bool)$annot->cdata;
                $classMetadata->xmlDiscriminatorNamespace = $annot->namespace ? (string)$annot->namespace : null;
            } elseif ($annot instanceof VirtualProperty) {
                $virtualPropertyMetadata = new ExpressionPropertyMetadata($name, $annot->name, $annot->exp);
                $propertiesMetadata[] = $virtualPropertyMetadata;
                $propertiesAnnotations[] = $annot->options;
            }
        }

        foreach ($class->getMethods() as $method) {
            if ($method->class !== $name) {
                continue;
            }

            $methodAnnotations = $this->reader->getMethodAnnotations($method);

            foreach ($methodAnnotations as $annot) {
                if ($annot instanceof PreSerialize) {
                    $classMetadata->addPreSerializeMethod(new MethodMetadata($name, $method->name));
                    continue 2;
                } elseif ($annot instanceof PostDeserialize) {
                    $classMetadata->addPostDeserializeMethod(new MethodMetadata($name, $method->name));
                    continue 2;
                } elseif ($annot instanceof PostSerialize) {
                    $classMetadata->addPostSerializeMethod(new MethodMetadata($name, $method->name));
                    continue 2;
                } elseif ($annot instanceof VirtualProperty) {
                    $virtualPropertyMetadata = new VirtualPropertyMetadata($name, $method->name);
                    $propertiesMetadata[] = $virtualPropertyMetadata;
                    $propertiesAnnotations[] = $methodAnnotations;
                    continue 2;
                }
            }
        }

        if (!$excludeAll) {
            foreach ($class->getProperties() as $property) {
                if ($property->class !== $name || (isset($property->info) && $property->info['class'] !== $name)) {

                    continue;
                }
                $propertiesMetadata[] = new PropertyMetadata($name, $property->getName());
                $propertiesAnnotations[] = $this->reader->getPropertyAnnotations($property);
            }

            foreach ($propertiesMetadata as $propertyKey => $propertyMetadata) {
                $isExclude = false;
                $isExpose = $propertyMetadata instanceof VirtualPropertyMetadata
                    || $propertyMetadata instanceof ExpressionPropertyMetadata;
                $propertyMetadata->readOnly = $propertyMetadata->readOnly || $readOnlyClass;
                $accessType = $classAccessType;
                $accessor = array(null, null);

                $propertyAnnotations = $propertiesAnnotations[$propertyKey];

                foreach ($propertyAnnotations as $annot) {
                    if ($annot instanceof Since) {
                        $propertyMetadata->sinceVersion = $annot->version;
                    } elseif ($annot instanceof Until) {
                        $propertyMetadata->untilVersion = $annot->version;
                    } elseif ($annot instanceof SerializedName) {
                        $propertyMetadata->serializedName = $annot->name;
                    } elseif ($annot instanceof SkipWhenEmpty) {
                        $propertyMetadata->skipWhenEmpty = true;
                    } elseif ($annot instanceof Expose) {
                        $isExpose = true;
                        if (null !== $annot->if) {
                            $propertyMetadata->excludeIf = "!(" . $annot->if . ")";
                        }
                    } elseif ($annot instanceof Exclude) {
                        if (null !== $annot->if) {
                            $propertyMetadata->excludeIf = $annot->if;
                        } else {
                            $isExclude = true;
                        }
                    } elseif ($annot instanceof Type) {
                        $propertyMetadata->setType($this->typeParser->parse($annot->name));
                    } elseif ($annot instanceof XmlElement) {
                        $propertyMetadata->xmlAttribute = false;
                        $propertyMetadata->xmlElementCData = $annot->cdata;
                        $propertyMetadata->xmlNamespace = $annot->namespace;
                    } elseif ($annot instanceof XmlList) {
                        $propertyMetadata->xmlCollection = true;
                        $propertyMetadata->xmlCollectionInline = $annot->inline;
                        $propertyMetadata->xmlEntryName = $annot->entry;
                        $propertyMetadata->xmlEntryNamespace = $annot->namespace;
                        $propertyMetadata->xmlCollectionSkipWhenEmpty = $annot->skipWhenEmpty;
                    } elseif ($annot instanceof XmlMap) {
                        $propertyMetadata->xmlCollection = true;
                        $propertyMetadata->xmlCollectionInline = $annot->inline;
                        $propertyMetadata->xmlEntryName = $annot->entry;
                        $propertyMetadata->xmlEntryNamespace = $annot->namespace;
                        $propertyMetadata->xmlKeyAttribute = $annot->keyAttribute;
                    } elseif ($annot instanceof XmlKeyValuePairs) {
                        $propertyMetadata->xmlKeyValuePairs = true;
                    } elseif ($annot instanceof XmlAttribute) {
                        $propertyMetadata->xmlAttribute = true;
                        $propertyMetadata->xmlNamespace = $annot->namespace;
                    } elseif ($annot instanceof XmlValue) {
                        $propertyMetadata->xmlValue = true;
                        $propertyMetadata->xmlElementCData = $annot->cdata;
                    } elseif ($annot instanceof XmlElement) {
                        $propertyMetadata->xmlElementCData = $annot->cdata;
                    } elseif ($annot instanceof AccessType) {
                        $accessType = $annot->type;
                    } elseif ($annot instanceof ReadOnly) {
                        $propertyMetadata->readOnly = $annot->readOnly;
                    } elseif ($annot instanceof Accessor) {
                        $accessor = array($annot->getter, $annot->setter);
                    } elseif ($annot instanceof Groups) {
                        $propertyMetadata->groups = $annot->groups;
                        foreach ((array)$propertyMetadata->groups as $groupName) {
                            if (false !== strpos($groupName, ',')) {
                                throw new InvalidArgumentException(sprintf(
                                    'Invalid group name "%s" on "%s", did you mean to create multiple groups?',
                                    implode(', ', $propertyMetadata->groups),
                                    $propertyMetadata->class . '->' . $propertyMetadata->name
                                ));
                            }
                        }
                    } elseif ($annot instanceof Inline) {
                        $propertyMetadata->inline = true;
                    } elseif ($annot instanceof XmlAttributeMap) {
                        $propertyMetadata->xmlAttributeMap = true;
                    } elseif ($annot instanceof MaxDepth) {
                        $propertyMetadata->maxDepth = $annot->depth;
                    }
                }


                if ((ExclusionPolicy::NONE === $exclusionPolicy && !$isExclude)
                    || (ExclusionPolicy::ALL === $exclusionPolicy && $isExpose)
                ) {
                    $propertyMetadata->setAccessor($accessType, $accessor[0], $accessor[1]);
                    $classMetadata->addPropertyMetadata($propertyMetadata);
                }
            }
        }

        return $classMetadata;
    }
}


1		<?php
2
3		/*
4		* Copyright 2016 Johannes M. Schmitt <[email protected]>
5		*
6		* Licensed under the Apache License, Version 2.0 (the "License");
7		* you may not use this file except in compliance with the License.
8		* You may obtain a copy of the License at
9		*
10		* http://www.apache.org/licenses/LICENSE-2.0
11		*
12		* Unless required by applicable law or agreed to in writing, software
13		* distributed under the License is distributed on an "AS IS" BASIS,
14		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15		* See the License for the specific language governing permissions and
16		* limitations under the License.
17		*/
18
19		namespace JMS\Serializer\Metadata\Driver;
20
21		use Doctrine\Common\Annotations\Reader;
22		use JMS\Parser\AbstractParser;
23		use JMS\Serializer\Annotation\Accessor;
24		use JMS\Serializer\Annotation\AccessorOrder;
25		use JMS\Serializer\Annotation\AccessType;
26		use JMS\Serializer\Annotation\Discriminator;
27		use JMS\Serializer\Annotation\Exclude;
28		use JMS\Serializer\Annotation\ExcludeIf;
29		use JMS\Serializer\Annotation\ExclusionPolicy;
30		use JMS\Serializer\Annotation\Expose;
31		use JMS\Serializer\Annotation\Groups;
32		use JMS\Serializer\Annotation\Inline;
33		use JMS\Serializer\Annotation\MaxDepth;
34		use JMS\Serializer\Annotation\PostDeserialize;
35		use JMS\Serializer\Annotation\PostSerialize;
36		use JMS\Serializer\Annotation\PreSerialize;
37		use JMS\Serializer\Annotation\ReadOnly;
38		use JMS\Serializer\Annotation\SerializedName;
39		use JMS\Serializer\Annotation\Since;
40		use JMS\Serializer\Annotation\SkipWhenEmpty;
41		use JMS\Serializer\Annotation\Type;
42		use JMS\Serializer\Annotation\Until;
43		use JMS\Serializer\Annotation\VirtualProperty;
44		use JMS\Serializer\Annotation\XmlAttribute;
45		use JMS\Serializer\Annotation\XmlAttributeMap;
46		use JMS\Serializer\Annotation\XmlDiscriminator;
47		use JMS\Serializer\Annotation\XmlElement;
48		use JMS\Serializer\Annotation\XmlKeyValuePairs;
49		use JMS\Serializer\Annotation\XmlList;
50		use JMS\Serializer\Annotation\XmlMap;
51		use JMS\Serializer\Annotation\XmlNamespace;
52		use JMS\Serializer\Annotation\XmlRoot;
53		use JMS\Serializer\Annotation\XmlValue;
54		use JMS\Serializer\Exception\InvalidArgumentException;
55		use JMS\Serializer\Metadata\ClassMetadata;
56		use JMS\Serializer\Metadata\ExpressionPropertyMetadata;
57		use JMS\Serializer\Metadata\PropertyMetadata;
58		use JMS\Serializer\Metadata\VirtualPropertyMetadata;
59		use JMS\Serializer\TypeParser;
60		use Metadata\Driver\DriverInterface;
61		use Metadata\MethodMetadata;
62
63		class AnnotationDriver implements DriverInterface
64		{
65		private $reader;
66		private $typeParser;
67
68	432	public function __construct(Reader $reader, AbstractParser $typeParser = null)
69		{
70	432	$this->reader = $reader;
71	432	$this->typeParser = $typeParser ?: new TypeParser();
72	432	}
73
74	269	public function loadMetadataForClass(\ReflectionClass $class)
75		{
76	269	$classMetadata = new ClassMetadata($name = $class->name);
77	269	$classMetadata->fileResources[] = $class->getFilename();
78
79	269	$propertiesMetadata = array();
80	269	$propertiesAnnotations = array();
81
82	269	$exclusionPolicy = 'NONE';
83	269	$excludeAll = false;
84	269	$classAccessType = PropertyMetadata::ACCESS_TYPE_PROPERTY;
85	269	$readOnlyClass = false;
86	269	foreach ($this->reader->getClassAnnotations($class) as $annot) {
87	157	if ($annot instanceof ExclusionPolicy) {
88	35	$exclusionPolicy = $annot->policy;
89	156	} elseif ($annot instanceof XmlRoot) {
90	69	$classMetadata->xmlRootName = $annot->name;
91	69	$classMetadata->xmlRootNamespace = $annot->namespace;
92	120	} elseif ($annot instanceof XmlNamespace) {
93	24	$classMetadata->registerNamespace($annot->uri, $annot->prefix);
94	98	} elseif ($annot instanceof Exclude) {
95		$excludeAll = true;
96	98	} elseif ($annot instanceof AccessType) {
97	5	$classAccessType = $annot->type;
98	95	} elseif ($annot instanceof ReadOnly) {
99	5	$readOnlyClass = true;
100	90	} elseif ($annot instanceof AccessorOrder) {
101	46	$classMetadata->setAccessorOrder($annot->order, $annot->custom);
102	44	} elseif ($annot instanceof Discriminator) {
103	22	if ($annot->disabled) {
104		$classMetadata->discriminatorDisabled = true;
105		} else {
106	22	$classMetadata->setDiscriminator($annot->field, $annot->map, $annot->groups);
107		}
108	27	} elseif ($annot instanceof XmlDiscriminator) {
109	5	$classMetadata->xmlDiscriminatorAttribute = (bool)$annot->attribute;
110	5	$classMetadata->xmlDiscriminatorCData = (bool)$annot->cdata;
111	5	$classMetadata->xmlDiscriminatorNamespace = $annot->namespace ? (string)$annot->namespace : null;
112	22	} elseif ($annot instanceof VirtualProperty) {
113	8	$virtualPropertyMetadata = new ExpressionPropertyMetadata($name, $annot->name, $annot->exp);
114	8	$propertiesMetadata[] = $virtualPropertyMetadata;
115	157	$propertiesAnnotations[] = $annot->options;
116		}
117		}
118
119	269	foreach ($class->getMethods() as $method) {
120	212	if ($method->class !== $name) {
121	19	continue;
122		}
123
124	211	$methodAnnotations = $this->reader->getMethodAnnotations($method);
125
126	211	foreach ($methodAnnotations as $annot) {
127	47	if ($annot instanceof PreSerialize) {
128	3	$classMetadata->addPreSerializeMethod(new MethodMetadata($name, $method->name));
129	3	continue 2;
130	47	} elseif ($annot instanceof PostDeserialize) {
131	6	$classMetadata->addPostDeserializeMethod(new MethodMetadata($name, $method->name));
132	6	continue 2;
133	44	} elseif ($annot instanceof PostSerialize) {
134	3	$classMetadata->addPostSerializeMethod(new MethodMetadata($name, $method->name));
135	3	continue 2;
136	41	} elseif ($annot instanceof VirtualProperty) {
137	41	$virtualPropertyMetadata = new VirtualPropertyMetadata($name, $method->name);
138	41	$propertiesMetadata[] = $virtualPropertyMetadata;
139	41	$propertiesAnnotations[] = $methodAnnotations;
140	211	continue 2;
141		}
142		}
143		}
144
145	269	if (!$excludeAll) {
146	269	foreach ($class->getProperties() as $property) {
147	249	if ($property->class !== $name \|\| (isset($property->info) && $property->info['class'] !== $name)) {
		0 ignored issues – show Bug introduced 2016-05-09 11:10 UTC by Report Bug Copy Issue Report The property `info` does not seem to exist in `ReflectionProperty`. An attempt at access to an undefined property has been detected. This may either be a typographical error or the property has been renamed but there are still references to its old name. If you really want to allow access to undefined properties, you can define magic methods to allow access. See the php core documentation on Overloading. Loading history...
148	21	continue;
149		}
150	248	$propertiesMetadata[] = new PropertyMetadata($name, $property->getName());
151	248	$propertiesAnnotations[] = $this->reader->getPropertyAnnotations($property);
152		}
153
154	269	foreach ($propertiesMetadata as $propertyKey => $propertyMetadata) {
155	257	$isExclude = false;
156	257	$isExpose = $propertyMetadata instanceof VirtualPropertyMetadata
157	257	\|\| $propertyMetadata instanceof ExpressionPropertyMetadata;
158	257	$propertyMetadata->readOnly = $propertyMetadata->readOnly \|\| $readOnlyClass;
159	257	$accessType = $classAccessType;
160	257	$accessor = array(null, null);
161
162	257	$propertyAnnotations = $propertiesAnnotations[$propertyKey];
163
164	257	foreach ($propertyAnnotations as $annot) {
165	254	if ($annot instanceof Since) {
166	7	$propertyMetadata->sinceVersion = $annot->version;
167	254	} elseif ($annot instanceof Until) {
168	7	$propertyMetadata->untilVersion = $annot->version;
169	254	} elseif ($annot instanceof SerializedName) {
170	87	$propertyMetadata->serializedName = $annot->name;
171	254	} elseif ($annot instanceof SkipWhenEmpty) {
172	7	$propertyMetadata->skipWhenEmpty = true;
173	253	} elseif ($annot instanceof Expose) {
174	37	$isExpose = true;
175	37	if (null !== $annot->if) {
176	37	$propertyMetadata->excludeIf = "!(" . $annot->if . ")";
177		}
178	253	} elseif ($annot instanceof Exclude) {
179	43	if (null !== $annot->if) {
180	21	$propertyMetadata->excludeIf = $annot->if;
181		} else {
182	43	$isExclude = true;
183		}
184	251	} elseif ($annot instanceof Type) {
185	210	$propertyMetadata->setType($this->typeParser->parse($annot->name));
186	166	} elseif ($annot instanceof XmlElement) {
187	21	$propertyMetadata->xmlAttribute = false;
188	21	$propertyMetadata->xmlElementCData = $annot->cdata;
189	21	$propertyMetadata->xmlNamespace = $annot->namespace;
190	160	} elseif ($annot instanceof XmlList) {
191	45	$propertyMetadata->xmlCollection = true;
192	45	$propertyMetadata->xmlCollectionInline = $annot->inline;
193	45	$propertyMetadata->xmlEntryName = $annot->entry;
194	45	$propertyMetadata->xmlEntryNamespace = $annot->namespace;
195	45	$propertyMetadata->xmlCollectionSkipWhenEmpty = $annot->skipWhenEmpty;
196	152	} elseif ($annot instanceof XmlMap) {
197	23	$propertyMetadata->xmlCollection = true;
198	23	$propertyMetadata->xmlCollectionInline = $annot->inline;
199	23	$propertyMetadata->xmlEntryName = $annot->entry;
200	23	$propertyMetadata->xmlEntryNamespace = $annot->namespace;
201	23	$propertyMetadata->xmlKeyAttribute = $annot->keyAttribute;
202	144	} elseif ($annot instanceof XmlKeyValuePairs) {
203	9	$propertyMetadata->xmlKeyValuePairs = true;
204	135	} elseif ($annot instanceof XmlAttribute) {
205	44	$propertyMetadata->xmlAttribute = true;
206	44	$propertyMetadata->xmlNamespace = $annot->namespace;
207	129	} elseif ($annot instanceof XmlValue) {
208	29	$propertyMetadata->xmlValue = true;
209	29	$propertyMetadata->xmlElementCData = $annot->cdata;
210	106	} elseif ($annot instanceof XmlElement) {
211		$propertyMetadata->xmlElementCData = $annot->cdata;
212	106	} elseif ($annot instanceof AccessType) {
213	3	$accessType = $annot->type;
214	106	} elseif ($annot instanceof ReadOnly) {
215	10	$propertyMetadata->readOnly = $annot->readOnly;
216	103	} elseif ($annot instanceof Accessor) {
217	11	$accessor = array($annot->getter, $annot->setter);
218	92	} elseif ($annot instanceof Groups) {
219	40	$propertyMetadata->groups = $annot->groups;
220	40	foreach ((array)$propertyMetadata->groups as $groupName) {
221	40	if (false !== strpos($groupName, ',')) {
222	3	throw new InvalidArgumentException(sprintf(
223	3	'Invalid group name "%s" on "%s", did you mean to create multiple groups?',
224	3	implode(', ', $propertyMetadata->groups),
225	40	$propertyMetadata->class . '->' . $propertyMetadata->name
226		));
227		}
228		}
229	70	} elseif ($annot instanceof Inline) {
230	7	$propertyMetadata->inline = true;
231	63	} elseif ($annot instanceof XmlAttributeMap) {
232	4	$propertyMetadata->xmlAttributeMap = true;
233	59	} elseif ($annot instanceof MaxDepth) {
234	251	$propertyMetadata->maxDepth = $annot->depth;
235		}
236		}
237
238
239	254	if ((ExclusionPolicy::NONE === $exclusionPolicy && !$isExclude)
240	254	\|\| (ExclusionPolicy::ALL === $exclusionPolicy && $isExpose)
241		) {
242	254	$propertyMetadata->setAccessor($accessType, $accessor[0], $accessor[1]);
243	254	$classMetadata->addPropertyMetadata($propertyMetadata);
244		}
245		}
246		}
247
248	266	return $classMetadata;
249		}
250		}
251

schmittjoh / serializer

Pull Request — master (#743)

AnnotationDriver::loadMetadataForClass() F

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like