GraphNavigator - Code Metrics - Inspection of "Merge branch 'zerkms-DESERIALIZE_EMPTY_XML_ERROR-m..." - schmittjoh/serializer - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 3674b7...0c820c )

by Asmir

created 2017-03-09 07:58 UTC

GraphNavigator F

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	306
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	17

Test Coverage

Coverage

91.21%

Importance

Changes

Metric	Value
wmc	77
lcom	1
cbo	17
dl	0
loc	306
ccs	166
cts	182
cp	0.9121
rs	2.1739
c	0
b	0
f	0

6 Methods

Rating	Name	Size	Complexity
A	parseDirection()	13	3
A	__construct()	16	2
D	resolveMetadata()	35	9
A	leaveScope()	8	3
C	afterVisitingObject()	25	8
F	accept()	173	52

How to fix 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;

use JMS\Serializer\EventDispatcher\ObjectEvent;
use JMS\Serializer\EventDispatcher\PreDeserializeEvent;
use JMS\Serializer\EventDispatcher\PreSerializeEvent;
use JMS\Serializer\Exception\RuntimeException;
use JMS\Serializer\Construction\ObjectConstructorInterface;
use JMS\Serializer\Handler\HandlerRegistryInterface;
use JMS\Serializer\EventDispatcher\EventDispatcherInterface;
use JMS\Serializer\Metadata\ClassMetadata;
use Metadata\MetadataFactoryInterface;
use JMS\Serializer\Exception\InvalidArgumentException;
use JMS\Serializer\Exception\ExpressionLanguageRequiredException;
use JMS\Serializer\Exclusion\ExpressionLanguageExclusionStrategy;
use JMS\Serializer\Expression\ExpressionEvaluatorInterface;

/**
 * Handles traversal along the object graph.
 *
 * This class handles traversal along the graph, and calls different methods
 * on visitors, or custom handlers to process its nodes.
 *
 * @author Johannes M. Schmitt <[email protected]>
 */
final class GraphNavigator
{
    const DIRECTION_SERIALIZATION = 1;
    const DIRECTION_DESERIALIZATION = 2;

    /**
     * @var ExpressionLanguageExclusionStrategy
     */
    private $expressionExclusionStrategy;

    private $dispatcher;
    private $metadataFactory;
    private $handlerRegistry;
    private $objectConstructor;

    /**
     * Parses a direction string to one of the direction constants.
     *
     * @param string $dirStr
     *
     * @return integer
     */
    public static function parseDirection($dirStr)
    {
        switch (strtolower($dirStr)) {
            case 'serialization':
                return self::DIRECTION_SERIALIZATION;

            case 'deserialization':
                return self::DIRECTION_DESERIALIZATION;

            default:
                throw new InvalidArgumentException(sprintf('The direction "%s" does not exist.', $dirStr));
        }
    }

    public function __construct(
        MetadataFactoryInterface $metadataFactory,
        HandlerRegistryInterface $handlerRegistry,
        ObjectConstructorInterface $objectConstructor,
        EventDispatcherInterface $dispatcher = null,
        ExpressionEvaluatorInterface $expressionEvaluator = null
    )
    {
        $this->dispatcher = $dispatcher;
        $this->metadataFactory = $metadataFactory;
        $this->handlerRegistry = $handlerRegistry;
        $this->objectConstructor = $objectConstructor;
        if ($expressionEvaluator) {
            $this->expressionExclusionStrategy = new ExpressionLanguageExclusionStrategy($expressionEvaluator);
        }
    }

    /**
     * Called for each node of the graph that is being traversed.
     *
     * @param mixed $data the data depends on the direction, and type of visitor
     * @param null|array $type array has the format ["name" => string, "params" => array]
     * @param Context $context
     * @return mixed the return value depends on the direction, and type of visitor
     */
    public function accept($data, array $type = null, Context $context)
    {
        $visitor = $context->getVisitor();

        // If the type was not given, we infer the most specific type from the
        // input data in serialization mode.
        if (null === $type) {
            if ($context instanceof DeserializationContext) {
                throw new RuntimeException('The type must be given for all properties when deserializing.');
            }

            $typeName = gettype($data);
            if ('object' === $typeName) {
                $typeName = get_class($data);
            }

            $type = array('name' => $typeName, 'params' => array());
        }
        // If the data is null, we have to force the type to null regardless of the input in order to
        // guarantee correct handling of null values, and not have any internal auto-casting behavior.
        else if ($context instanceof SerializationContext && null === $data) {
            $type = array('name' => 'NULL', 'params' => array());
        }

        switch ($type['name']) {
            case 'NULL':
                return $visitor->visitNull($data, $type, $context);

            case 'string':
                return $visitor->visitString($data, $type, $context);

            case 'int':
            case 'integer':
                return $visitor->visitInteger($data, $type, $context);

            case 'boolean':
                return $visitor->visitBoolean($data, $type, $context);

            case 'double':
            case 'float':
                return $visitor->visitDouble($data, $type, $context);

            case 'array':
                return $visitor->visitArray($data, $type, $context);

            case 'resource':
                $msg = 'Resources are not supported in serialized data.';
                if ($context instanceof SerializationContext && null !== $path = $context->getPath()) {
                    $msg .= ' Path: '.$path;
                }

                throw new RuntimeException($msg);

            default:
                // TODO: The rest of this method needs some refactoring.
                if ($context instanceof SerializationContext) {
                    if (null !== $data) {
                        if ($context->isVisiting($data)) {
                            return null;
                        }
                        $context->startVisiting($data);
                    }

                    // If we're serializing a polymorphic type, then we'll be interested in the
                    // metadata for the actual type of the object, not the base class.
                    if (class_exists($type['name'], false) || interface_exists($type['name'], false)) {
                        if (is_subclass_of($data, $type['name'], false)) {

                            $type = array('name' => get_class($data), 'params' => array());
                        }
                    }
                } elseif ($context instanceof DeserializationContext) {
                    $context->increaseDepth();
                }

                // Trigger pre-serialization callbacks, and listeners if they exist.
                // Dispatch pre-serialization event before handling data to have ability change type in listener
                if ($context instanceof SerializationContext) {
                    if (null !== $this->dispatcher && $this->dispatcher->hasListeners('serializer.pre_serialize', $type['name'], $context->getFormat())) {
                        $this->dispatcher->dispatch('serializer.pre_serialize', $type['name'], $context->getFormat(), $event = new PreSerializeEvent($context, $data, $type));
                        $type = $event->getType();
                    }
                } elseif ($context instanceof DeserializationContext) {
                    if (null !== $this->dispatcher && $this->dispatcher->hasListeners('serializer.pre_deserialize', $type['name'], $context->getFormat())) {
                        $this->dispatcher->dispatch('serializer.pre_deserialize', $type['name'], $context->getFormat(), $event = new PreDeserializeEvent($context, $data, $type));
                        $type = $event->getType();
                        $data = $event->getData();
                    }
                }

                // First, try whether a custom handler exists for the given type. This is done
                // before loading metadata because the type name might not be a class, but
                // could also simply be an artifical type.
                if (null !== $handler = $this->handlerRegistry->getHandler($context->getDirection(), $type['name'], $context->getFormat())) {
                    $rs = call_user_func($handler, $visitor, $data, $type, $context);
                    $this->leaveScope($context, $data);

                    return $rs;
                }

                $exclusionStrategy = $context->getExclusionStrategy();

                /** @var $metadata ClassMetadata */
                $metadata = $this->metadataFactory->getMetadataForClass($type['name']);

                if ($metadata->usingExpression && !$this->expressionExclusionStrategy) {
                    throw new ExpressionLanguageRequiredException("To use conditional exclude/expose in {$metadata->name} you must configure the expression language.");
                }

                if ($context instanceof DeserializationContext && ! empty($metadata->discriminatorMap) && $type['name'] === $metadata->discriminatorBaseClass) {
                    $metadata = $this->resolveMetadata($data, $metadata);
                }

                if (null !== $exclusionStrategy && $exclusionStrategy->shouldSkipClass($metadata, $context)) {
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                    $this->leaveScope($context, $data);

                    return null;
                }

                $context->pushClassMetadata($metadata);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

                if ($context instanceof SerializationContext) {
                    foreach ($metadata->preSerializeMethods as $method) {
                        $method->invoke($data);
                    }
                }

                $object = $data;
                if ($context instanceof DeserializationContext) {
                    $object = $this->objectConstructor->construct($visitor, $metadata, $data, $type, $context);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                }

                if (isset($metadata->handlerCallbacks[$context->getDirection()][$context->getFormat()])) {
                    $rs = $object->{$metadata->handlerCallbacks[$context->getDirection()][$context->getFormat()]}(
                        $visitor,
                        $context instanceof SerializationContext ? null : $data,
                        $context
                    );
                    $this->afterVisitingObject($metadata, $object, $type, $context);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

                    return $context instanceof SerializationContext ? $rs : $object;
                }

                $visitor->startVisitingObject($metadata, $object, $type, $context);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                foreach ($metadata->propertyMetadata as $propertyMetadata) {
                    if (null !== $exclusionStrategy && $exclusionStrategy->shouldSkipProperty($propertyMetadata, $context)) {
                        continue;
                    }

                    if (null !== $this->expressionExclusionStrategy && $this->expressionExclusionStrategy->shouldSkipProperty($propertyMetadata, $context)) {
                        continue;
                    }

                    if ($context instanceof DeserializationContext && $propertyMetadata->readOnly) {
                        continue;
                    }

                    $context->pushPropertyMetadata($propertyMetadata);
                    $visitor->visitProperty($propertyMetadata, $data, $context);
                    $context->popPropertyMetadata();
                }

                if ($context instanceof SerializationContext) {
                    $this->afterVisitingObject($metadata, $data, $type, $context);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

                    return $visitor->endVisitingObject($metadata, $data, $type, $context);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                }

                $rs = $visitor->endVisitingObject($metadata, $data, $type, $context);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                $this->afterVisitingObject($metadata, $rs, $type, $context);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

                return $rs;
        }
    }

    private function resolveMetadata($data, ClassMetadata $metadata)
    {
        switch (true) {
            case is_array($data) && isset($data[$metadata->discriminatorFieldName]):
                $typeValue = (string) $data[$metadata->discriminatorFieldName];
                break;

            // Check XML attribute for discriminatorFieldName
            case is_object($data) && $metadata->xmlDiscriminatorAttribute && isset($data[$metadata->discriminatorFieldName]):
                $typeValue = (string) $data[$metadata->discriminatorFieldName];
                break;

            case is_object($data) && isset($data->{$metadata->discriminatorFieldName}):
                $typeValue = (string) $data->{$metadata->discriminatorFieldName};
                break;

            default:
                throw new \LogicException(sprintf(
                    'The discriminator field name "%s" for base-class "%s" was not found in input data.',
                    $metadata->discriminatorFieldName,
                    $metadata->name
                ));
        }

        if ( ! isset($metadata->discriminatorMap[$typeValue])) {
            throw new \LogicException(sprintf(
                'The type value "%s" does not exist in the discriminator map of class "%s". Available types: %s',
                $typeValue,
                $metadata->name,
                implode(', ', array_keys($metadata->discriminatorMap))
            ));
        }

        return $this->metadataFactory->getMetadataForClass($metadata->discriminatorMap[$typeValue]);
    }

    private function leaveScope(Context $context, $data)
    {
        if ($context instanceof SerializationContext) {
            $context->stopVisiting($data);
        } elseif ($context instanceof DeserializationContext) {
            $context->decreaseDepth();
        }
    }

    private function afterVisitingObject(ClassMetadata $metadata, $object, array $type, Context $context)
    {
        $this->leaveScope($context, $object);
        $context->popClassMetadata();

        if ($context instanceof SerializationContext) {
            foreach ($metadata->postSerializeMethods as $method) {
                $method->invoke($object);
            }

            if (null !== $this->dispatcher && $this->dispatcher->hasListeners('serializer.post_serialize', $metadata->name, $context->getFormat())) {
                $this->dispatcher->dispatch('serializer.post_serialize', $metadata->name, $context->getFormat(), new ObjectEvent($context, $object, $type));
            }

            return;
        }

        foreach ($metadata->postDeserializeMethods as $method) {
            $method->invoke($object);
        }

        if (null !== $this->dispatcher && $this->dispatcher->hasListeners('serializer.post_deserialize', $metadata->name, $context->getFormat())) {
            $this->dispatcher->dispatch('serializer.post_deserialize', $metadata->name, $context->getFormat(), new ObjectEvent($context, $object, $type));
        }
    }
}


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;
20
21		use JMS\Serializer\EventDispatcher\ObjectEvent;
22		use JMS\Serializer\EventDispatcher\PreDeserializeEvent;
23		use JMS\Serializer\EventDispatcher\PreSerializeEvent;
24		use JMS\Serializer\Exception\RuntimeException;
25		use JMS\Serializer\Construction\ObjectConstructorInterface;
26		use JMS\Serializer\Handler\HandlerRegistryInterface;
27		use JMS\Serializer\EventDispatcher\EventDispatcherInterface;
28		use JMS\Serializer\Metadata\ClassMetadata;
29		use Metadata\MetadataFactoryInterface;
30		use JMS\Serializer\Exception\InvalidArgumentException;
31		use JMS\Serializer\Exception\ExpressionLanguageRequiredException;
32		use JMS\Serializer\Exclusion\ExpressionLanguageExclusionStrategy;
33		use JMS\Serializer\Expression\ExpressionEvaluatorInterface;
34
35		/**
36		* Handles traversal along the object graph.
37		*
38		* This class handles traversal along the graph, and calls different methods
39		* on visitors, or custom handlers to process its nodes.
40		*
41		* @author Johannes M. Schmitt <[email protected]>
42		*/
43		final class GraphNavigator
44		{
45		const DIRECTION_SERIALIZATION = 1;
46		const DIRECTION_DESERIALIZATION = 2;
47
48		/**
49		* @var ExpressionLanguageExclusionStrategy
50		*/
51		private $expressionExclusionStrategy;
52
53		private $dispatcher;
54		private $metadataFactory;
55		private $handlerRegistry;
56		private $objectConstructor;
57
58		/**
59		* Parses a direction string to one of the direction constants.
60		*
61		* @param string $dirStr
62		*
63		* @return integer
64		*/
65	6	public static function parseDirection($dirStr)
66		{
67	6	switch (strtolower($dirStr)) {
68	6	case 'serialization':
69	6	return self::DIRECTION_SERIALIZATION;
70
71	3	case 'deserialization':
72	3	return self::DIRECTION_DESERIALIZATION;
73
74		default:
75		throw new InvalidArgumentException(sprintf('The direction "%s" does not exist.', $dirStr));
76		}
77		}
78
79	324	public function __construct(
80		MetadataFactoryInterface $metadataFactory,
81		HandlerRegistryInterface $handlerRegistry,
82		ObjectConstructorInterface $objectConstructor,
83		EventDispatcherInterface $dispatcher = null,
84		ExpressionEvaluatorInterface $expressionEvaluator = null
85		)
86		{
87	324	$this->dispatcher = $dispatcher;
88	324	$this->metadataFactory = $metadataFactory;
89	324	$this->handlerRegistry = $handlerRegistry;
90	324	$this->objectConstructor = $objectConstructor;
91	324	if ($expressionEvaluator) {
92	29	$this->expressionExclusionStrategy = new ExpressionLanguageExclusionStrategy($expressionEvaluator);
93	29	}
94	324	}
95
96		/**
97		* Called for each node of the graph that is being traversed.
98		*
99		* @param mixed $data the data depends on the direction, and type of visitor
100		* @param null\|array $type array has the format ["name" => string, "params" => array]
101		* @param Context $context
102		* @return mixed the return value depends on the direction, and type of visitor
103		*/
104	307	public function accept($data, array $type = null, Context $context)
105		{
106	307	$visitor = $context->getVisitor();
107
108		// If the type was not given, we infer the most specific type from the
109		// input data in serialization mode.
110	307	if (null === $type) {
111	288	if ($context instanceof DeserializationContext) {
112		throw new RuntimeException('The type must be given for all properties when deserializing.');
113	8	}
114
115	288	$typeName = gettype($data);
116	288	if ('object' === $typeName) {
117	213	$typeName = get_class($data);
118	213	}
119
120	288	$type = array('name' => $typeName, 'params' => array());
121	288	}
122		// If the data is null, we have to force the type to null regardless of the input in order to
123		// guarantee correct handling of null values, and not have any internal auto-casting behavior.
124	219	else if ($context instanceof SerializationContext && null === $data) {
125	15	$type = array('name' => 'NULL', 'params' => array());
126	15	}
127
128	307	switch ($type['name']) {
129	307	case 'NULL':
130	45	return $visitor->visitNull($data, $type, $context);
131
132	299	case 'string':
133	173	return $visitor->visitString($data, $type, $context);
134
135	292	case 'int':
136	292	case 'integer':
137	51	return $visitor->visitInteger($data, $type, $context);
138
139	286	case 'boolean':
140	22	return $visitor->visitBoolean($data, $type, $context);
141
142	275	case 'double':
143	275	case 'float':
144	36	return $visitor->visitDouble($data, $type, $context);
145
146	258	case 'array':
147	93	return $visitor->visitArray($data, $type, $context);
148
149	228	case 'resource':
150	1	$msg = 'Resources are not supported in serialized data.';
151	1	if ($context instanceof SerializationContext && null !== $path = $context->getPath()) {
152		$msg .= ' Path: '.$path;
153		}
154
155	1	throw new RuntimeException($msg);
156
157	227	default:
158		// TODO: The rest of this method needs some refactoring.
159	227	if ($context instanceof SerializationContext) {
160	211	if (null !== $data) {
161	211	if ($context->isVisiting($data)) {
162	3	return null;
163		}
164	211	$context->startVisiting($data);
165	211	}
166
167		// If we're serializing a polymorphic type, then we'll be interested in the
168		// metadata for the actual type of the object, not the base class.
169	211	if (class_exists($type['name'], false) \|\| interface_exists($type['name'], false)) {
170	211	if (is_subclass_of($data, $type['name'], false)) {
		0 ignored issues – show Bug introduced 2016-04-25 12:28 UTC by Report Bug Copy Issue Report Due to PHP Bug #53727, `is_subclass_of` might return inconsistent results on some PHP versions if `$type['name']` can be an interface. If so, you could instead use `ReflectionClass::implementsInterface`. Loading history...
171	6	$type = array('name' => get_class($data), 'params' => array());
172	6	}
173	211	}
174	227	} elseif ($context instanceof DeserializationContext) {
175	69	$context->increaseDepth();
176	69	}
177
178		// Trigger pre-serialization callbacks, and listeners if they exist.
179		// Dispatch pre-serialization event before handling data to have ability change type in listener
180	227	if ($context instanceof SerializationContext) {
181	211	if (null !== $this->dispatcher && $this->dispatcher->hasListeners('serializer.pre_serialize', $type['name'], $context->getFormat())) {
182	206	$this->dispatcher->dispatch('serializer.pre_serialize', $type['name'], $context->getFormat(), $event = new PreSerializeEvent($context, $data, $type));
183	206	$type = $event->getType();
184	206	}
185	227	} elseif ($context instanceof DeserializationContext) {
186	69	if (null !== $this->dispatcher && $this->dispatcher->hasListeners('serializer.pre_deserialize', $type['name'], $context->getFormat())) {
187		$this->dispatcher->dispatch('serializer.pre_deserialize', $type['name'], $context->getFormat(), $event = new PreDeserializeEvent($context, $data, $type));
188		$type = $event->getType();
189		$data = $event->getData();
190		}
191	69	}
192
193		// First, try whether a custom handler exists for the given type. This is done
194		// before loading metadata because the type name might not be a class, but
195		// could also simply be an artifical type.
196	227	if (null !== $handler = $this->handlerRegistry->getHandler($context->getDirection(), $type['name'], $context->getFormat())) {
197	55	$rs = call_user_func($handler, $visitor, $data, $type, $context);
198	55	$this->leaveScope($context, $data);
199
200	55	return $rs;
201		}
202
203	203	$exclusionStrategy = $context->getExclusionStrategy();
204
205		/** @var $metadata ClassMetadata */
206	203	$metadata = $this->metadataFactory->getMetadataForClass($type['name']);
207
208	200	if ($metadata->usingExpression && !$this->expressionExclusionStrategy) {
209	3	throw new ExpressionLanguageRequiredException("To use conditional exclude/expose in {$metadata->name} you must configure the expression language.");
210		}
211
212	197	if ($context instanceof DeserializationContext && ! empty($metadata->discriminatorMap) && $type['name'] === $metadata->discriminatorBaseClass) {
213	12	$metadata = $this->resolveMetadata($data, $metadata);
214	10	}
215
216	195	if (null !== $exclusionStrategy && $exclusionStrategy->shouldSkipClass($metadata, $context)) {
		0 ignored issues – show Documentation introduced 2015-11-21 10:57 UTC by Report Bug Copy Issue Report `$metadata` is of type `object<Metadata\ClassHie...ableClassMetadata>\|null`, but the function expects a `object<JMS\Serializer\Metadata\ClassMetadata>`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
217	3	$this->leaveScope($context, $data);
218
219	3	return null;
220		}
221
222	195	$context->pushClassMetadata($metadata);
		0 ignored issues – show Documentation introduced 2015-11-21 10:57 UTC by Report Bug Copy Issue Report `$metadata` is of type `object<Metadata\ClassHie...ableClassMetadata>\|null`, but the function expects a `object<JMS\Serializer\Metadata\ClassMetadata>`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
223
224	195	if ($context instanceof SerializationContext) {
225	183	foreach ($metadata->preSerializeMethods as $method) {
226	3	$method->invoke($data);
227	183	}
228	183	}
229
230	195	$object = $data;
231	195	if ($context instanceof DeserializationContext) {
232	57	$object = $this->objectConstructor->construct($visitor, $metadata, $data, $type, $context);
		0 ignored issues – show Documentation introduced 2015-11-21 10:57 UTC by Report Bug Copy Issue Report `$metadata` is of type `object<Metadata\ClassHie...ableClassMetadata>\|null`, but the function expects a `object<JMS\Serializer\Metadata\ClassMetadata>`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
233	57	}
234
235	195	if (isset($metadata->handlerCallbacks[$context->getDirection()][$context->getFormat()])) {
236	3	$rs = $object->{$metadata->handlerCallbacks[$context->getDirection()][$context->getFormat()]}(
237	3	$visitor,
238	3	$context instanceof SerializationContext ? null : $data,
239		$context
240	3	);
241	3	$this->afterVisitingObject($metadata, $object, $type, $context);
		0 ignored issues – show Documentation introduced 2015-11-21 10:57 UTC by Report Bug Copy Issue Report `$metadata` is of type `object<Metadata\ClassHie...MergeableClassMetadata>`, but the function expects a `object<JMS\Serializer\Metadata\ClassMetadata>`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
242
243	3	return $context instanceof SerializationContext ? $rs : $object;
244		}
245
246	192	$visitor->startVisitingObject($metadata, $object, $type, $context);
		0 ignored issues – show Documentation introduced 2015-11-21 10:57 UTC by Report Bug Copy Issue Report `$metadata` is of type `object<Metadata\ClassHie...MergeableClassMetadata>`, but the function expects a `object<JMS\Serializer\Metadata\ClassMetadata>`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
247	192	foreach ($metadata->propertyMetadata as $propertyMetadata) {
248	189	if (null !== $exclusionStrategy && $exclusionStrategy->shouldSkipProperty($propertyMetadata, $context)) {
249	13	continue;
250		}
251
252	189	if (null !== $this->expressionExclusionStrategy && $this->expressionExclusionStrategy->shouldSkipProperty($propertyMetadata, $context)) {
253	23	continue;
254		}
255
256	189	if ($context instanceof DeserializationContext && $propertyMetadata->readOnly) {
257	16	continue;
258		}
259
260	189	$context->pushPropertyMetadata($propertyMetadata);
261	189	$visitor->visitProperty($propertyMetadata, $data, $context);
262	188	$context->popPropertyMetadata();
263	191	}
264
265	189	if ($context instanceof SerializationContext) {
266	178	$this->afterVisitingObject($metadata, $data, $type, $context);
		0 ignored issues – show Documentation introduced 2015-11-21 10:57 UTC by Report Bug Copy Issue Report `$metadata` is of type `object<Metadata\ClassHie...MergeableClassMetadata>`, but the function expects a `object<JMS\Serializer\Metadata\ClassMetadata>`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
267
268	178	return $visitor->endVisitingObject($metadata, $data, $type, $context);
		0 ignored issues – show Documentation introduced 2015-11-21 10:57 UTC by Report Bug Copy Issue Report `$metadata` is of type `object<Metadata\ClassHie...MergeableClassMetadata>`, but the function expects a `object<JMS\Serializer\Metadata\ClassMetadata>`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
269		}
270
271	57	$rs = $visitor->endVisitingObject($metadata, $data, $type, $context);
		0 ignored issues – show Documentation introduced 2015-11-21 10:57 UTC by Report Bug Copy Issue Report `$metadata` is of type `object<Metadata\ClassHie...MergeableClassMetadata>`, but the function expects a `object<JMS\Serializer\Metadata\ClassMetadata>`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
272	57	$this->afterVisitingObject($metadata, $rs, $type, $context);
		0 ignored issues – show Documentation introduced 2015-11-21 10:57 UTC by Report Bug Copy Issue Report `$metadata` is of type `object<Metadata\ClassHie...MergeableClassMetadata>`, but the function expects a `object<JMS\Serializer\Metadata\ClassMetadata>`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
273
274	57	return $rs;
275	227	}
276		}
277
278	12	private function resolveMetadata($data, ClassMetadata $metadata)
279		{
280	12	switch (true) {
281	12	case is_array($data) && isset($data[$metadata->discriminatorFieldName]):
282	5	$typeValue = (string) $data[$metadata->discriminatorFieldName];
283	5	break;
284
285		// Check XML attribute for discriminatorFieldName
286	7	case is_object($data) && $metadata->xmlDiscriminatorAttribute && isset($data[$metadata->discriminatorFieldName]):
287	1	$typeValue = (string) $data[$metadata->discriminatorFieldName];
288	1	break;
289
290	6	case is_object($data) && isset($data->{$metadata->discriminatorFieldName}):
291	4	$typeValue = (string) $data->{$metadata->discriminatorFieldName};
292	4	break;
293
294	2	default:
295	2	throw new \LogicException(sprintf(
296	2	'The discriminator field name "%s" for base-class "%s" was not found in input data.',
297	2	$metadata->discriminatorFieldName,
298	2	$metadata->name
299	2	));
300	2	}
301
302	10	if ( ! isset($metadata->discriminatorMap[$typeValue])) {
303		throw new \LogicException(sprintf(
304		'The type value "%s" does not exist in the discriminator map of class "%s". Available types: %s',
305		$typeValue,
306		$metadata->name,
307		implode(', ', array_keys($metadata->discriminatorMap))
308		));
309		}
310
311	10	return $this->metadataFactory->getMetadataForClass($metadata->discriminatorMap[$typeValue]);
312		}
313
314	216	private function leaveScope(Context $context, $data)
315		{
316	216	if ($context instanceof SerializationContext) {
317	203	$context->stopVisiting($data);
318	216	} elseif ($context instanceof DeserializationContext) {
319	66	$context->decreaseDepth();
320	66	}
321	216	}
322
323	192	private function afterVisitingObject(ClassMetadata $metadata, $object, array $type, Context $context)
324		{
325	192	$this->leaveScope($context, $object);
326	192	$context->popClassMetadata();
327
328	192	if ($context instanceof SerializationContext) {
329	181	foreach ($metadata->postSerializeMethods as $method) {
330	3	$method->invoke($object);
331	181	}
332
333	181	if (null !== $this->dispatcher && $this->dispatcher->hasListeners('serializer.post_serialize', $metadata->name, $context->getFormat())) {
334	2	$this->dispatcher->dispatch('serializer.post_serialize', $metadata->name, $context->getFormat(), new ObjectEvent($context, $object, $type));
335	2	}
336
337	181	return;
338		}
339
340	59	foreach ($metadata->postDeserializeMethods as $method) {
341	4	$method->invoke($object);
342	59	}
343
344	59	if (null !== $this->dispatcher && $this->dispatcher->hasListeners('serializer.post_deserialize', $metadata->name, $context->getFormat())) {
345	1	$this->dispatcher->dispatch('serializer.post_deserialize', $metadata->name, $context->getFormat(), new ObjectEvent($context, $object, $type));
346	1	}
347	59	}
348		}
349

schmittjoh / serializer

Push — master ( 3674b7...0c820c )

GraphNavigator F

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

6 Methods

How to fix Complexity

Complex Class

Duplication Side-by-Side

Filter issues like