YamlDriver::getExtension() - Code Metrics - Inspection of "Added deserialize type" - schmittjoh/serializer - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#787)

unknown

created 2017-06-17 17:08 UTC

YamlDriver::getExtension() A

↳ Parent: YamlDriver

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes

Metric	Value
c	0
b	0
f	0
dl	0
loc	4
ccs	2
cts	2
cp	1
rs	10
cc	1
eloc	2
nc	1
nop	0
crap	1

<?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 JMS\Serializer\Annotation\ExclusionPolicy;
use JMS\Serializer\Exception\RuntimeException;
use JMS\Serializer\GraphNavigator;
use JMS\Serializer\Metadata\ClassMetadata;
use JMS\Serializer\Metadata\ExpressionPropertyMetadata;
use JMS\Serializer\Metadata\PropertyMetadata;
use JMS\Serializer\Metadata\VirtualPropertyMetadata;
use Metadata\Driver\AbstractFileDriver;
use Metadata\MethodMetadata;
use Symfony\Component\Yaml\Yaml;

class YamlDriver extends AbstractFileDriver
{
    protected function loadMetadataFromFile(\ReflectionClass $class, $file)
    {
        $config = Yaml::parse(file_get_contents($file));

        if (!isset($config[$name = $class->name])) {
            throw new RuntimeException(sprintf('Expected metadata for class %s to be defined in %s.', $class->name, $file));
        }

        $config = $config[$name];
        $metadata = new ClassMetadata($name);
        $metadata->fileResources[] = $file;
        $metadata->fileResources[] = $class->getFileName();
        $exclusionPolicy = isset($config['exclusion_policy']) ? strtoupper($config['exclusion_policy']) : 'NONE';
        $excludeAll = isset($config['exclude']) ? (Boolean)$config['exclude'] : false;
        $classAccessType = isset($config['access_type']) ? $config['access_type'] : PropertyMetadata::ACCESS_TYPE_PROPERTY;
        $readOnlyClass = isset($config['read_only']) ? (Boolean)$config['read_only'] : false;
        $this->addClassProperties($metadata, $config);

        $propertiesMetadata = array();
        if (array_key_exists('virtual_properties', $config)) {
            foreach ($config['virtual_properties'] as $methodName => $propertySettings) {
                if (isset($propertySettings['exp'])) {
                    $virtualPropertyMetadata = new ExpressionPropertyMetadata($name, $methodName, $propertySettings['exp']);
                    unset($propertySettings['exp']);

                } else {

                    if (!$class->hasMethod($methodName)) {
                        throw new RuntimeException('The method ' . $methodName . ' not found in class ' . $class->name);
                    }
                    $virtualPropertyMetadata = new VirtualPropertyMetadata($name, $methodName);
                }
                $propertiesMetadata[$methodName] = $virtualPropertyMetadata;
                $config['properties'][$methodName] = $propertySettings;
            }
        }

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

                    continue;
                }

                $pName = $property->getName();
                $propertiesMetadata[$pName] = new PropertyMetadata($name, $pName);
            }

            foreach ($propertiesMetadata as $pName => $pMetadata) {
                $isExclude = false;
                $isExpose = $pMetadata instanceof VirtualPropertyMetadata
                    || $pMetadata instanceof ExpressionPropertyMetadata
                    || (isset($config['properties']) && array_key_exists($pName, $config['properties']));

                if (isset($config['properties'][$pName])) {
                    $pConfig = $config['properties'][$pName];

                    if (isset($pConfig['exclude'])) {
                        $isExclude = (Boolean)$pConfig['exclude'];
                    }

                    if (isset($pConfig['expose'])) {
                        $isExpose = (Boolean)$pConfig['expose'];
                    }

                    if (isset($pConfig['skip_when_empty'])) {
                        $pMetadata->skipWhenEmpty = (Boolean)$pConfig['skip_when_empty'];
                    }

                    if (isset($pConfig['since_version'])) {
                        $pMetadata->sinceVersion = (string)$pConfig['since_version'];
                    }

                    if (isset($pConfig['until_version'])) {
                        $pMetadata->untilVersion = (string)$pConfig['until_version'];
                    }

                    if (isset($pConfig['exclude_if'])) {
                        $pMetadata->excludeIf = (string)$pConfig['exclude_if'];
                    }

                    if (isset($pConfig['expose_if'])) {
                        $pMetadata->excludeIf = "!(" . $pConfig['expose_if'] . ")";
                    }

                    if (isset($pConfig['serialized_name'])) {
                        $pMetadata->serializedName = (string)$pConfig['serialized_name'];
                    }

                    if (isset($pConfig['type'])) {
                        $pMetadata->setType((string)$pConfig['type']);
                    }

                    if (isset($pConfig['deserializeType'])) {
                        $pMetadata->setDeserializeType((string)$pConfig['deserializeType']);
                    }

                    if (isset($pConfig['groups'])) {
                        $pMetadata->groups = $pConfig['groups'];
                    }

                    if (isset($pConfig['xml_list'])) {
                        $pMetadata->xmlCollection = true;

                        $colConfig = $pConfig['xml_list'];
                        if (isset($colConfig['inline'])) {
                            $pMetadata->xmlCollectionInline = (Boolean)$colConfig['inline'];
                        }

                        if (isset($colConfig['entry_name'])) {
                            $pMetadata->xmlEntryName = (string)$colConfig['entry_name'];
                        }

                        if (isset($colConfig['skip_when_empty'])) {
                            $pMetadata->xmlCollectionSkipWhenEmpty = (Boolean)$colConfig['skip_when_empty'];
                        } else {
                            $pMetadata->xmlCollectionSkipWhenEmpty = true;
                        }

                        if (isset($colConfig['namespace'])) {
                            $pMetadata->xmlEntryNamespace = (string)$colConfig['namespace'];
                        }
                    }

                    if (isset($pConfig['xml_map'])) {
                        $pMetadata->xmlCollection = true;

                        $colConfig = $pConfig['xml_map'];
                        if (isset($colConfig['inline'])) {
                            $pMetadata->xmlCollectionInline = (Boolean)$colConfig['inline'];
                        }

                        if (isset($colConfig['entry_name'])) {
                            $pMetadata->xmlEntryName = (string)$colConfig['entry_name'];
                        }

                        if (isset($colConfig['namespace'])) {
                            $pMetadata->xmlEntryNamespace = (string)$colConfig['namespace'];
                        }

                        if (isset($colConfig['key_attribute_name'])) {
                            $pMetadata->xmlKeyAttribute = $colConfig['key_attribute_name'];
                        }

                    }

                    if (isset($pConfig['xml_element'])) {
                        $colConfig = $pConfig['xml_element'];
                        if (isset($colConfig['cdata'])) {
                            $pMetadata->xmlElementCData = (Boolean)$colConfig['cdata'];
                        }

                        if (isset($colConfig['namespace'])) {
                            $pMetadata->xmlNamespace = (string)$colConfig['namespace'];
                        }
                    }

                    if (isset($pConfig['xml_attribute'])) {
                        $pMetadata->xmlAttribute = (Boolean)$pConfig['xml_attribute'];
                    }

                    if (isset($pConfig['xml_attribute_map'])) {
                        $pMetadata->xmlAttributeMap = (Boolean)$pConfig['xml_attribute_map'];
                    }

                    if (isset($pConfig['xml_value'])) {
                        $pMetadata->xmlValue = (Boolean)$pConfig['xml_value'];
                    }

                    if (isset($pConfig['xml_key_value_pairs'])) {
                        $pMetadata->xmlKeyValuePairs = (Boolean)$pConfig['xml_key_value_pairs'];
                    }

                    //we need read_only before setter and getter set, because that method depends on flag being set
                    if (isset($pConfig['read_only'])) {
                        $pMetadata->readOnly = (Boolean)$pConfig['read_only'];
                    } else {
                        $pMetadata->readOnly = $pMetadata->readOnly || $readOnlyClass;
                    }

                    $pMetadata->setAccessor(
                        isset($pConfig['access_type']) ? $pConfig['access_type'] : $classAccessType,
                        isset($pConfig['accessor']['getter']) ? $pConfig['accessor']['getter'] : null,
                        isset($pConfig['accessor']['setter']) ? $pConfig['accessor']['setter'] : null
                    );

                    if (isset($pConfig['inline'])) {
                        $pMetadata->inline = (Boolean)$pConfig['inline'];
                    }

                    if (isset($pConfig['max_depth'])) {
                        $pMetadata->maxDepth = (int)$pConfig['max_depth'];
                    }
                }
                if ((ExclusionPolicy::NONE === $exclusionPolicy && !$isExclude)
                    || (ExclusionPolicy::ALL === $exclusionPolicy && $isExpose)
                ) {
                    $metadata->addPropertyMetadata($pMetadata);
                }
            }
        }

        if (isset($config['handler_callbacks'])) {
            foreach ($config['handler_callbacks'] as $directionName => $formats) {
                $direction = GraphNavigator::parseDirection($directionName);
                foreach ($formats as $format => $methodName) {
                    $metadata->addHandlerCallback($direction, $format, $methodName);
                }
            }
        }

        if (isset($config['callback_methods'])) {
            $cConfig = $config['callback_methods'];

            if (isset($cConfig['pre_serialize'])) {
                $metadata->preSerializeMethods = $this->getCallbackMetadata($class, $cConfig['pre_serialize']);
            }
            if (isset($cConfig['post_serialize'])) {
                $metadata->postSerializeMethods = $this->getCallbackMetadata($class, $cConfig['post_serialize']);
            }
            if (isset($cConfig['post_deserialize'])) {
                $metadata->postDeserializeMethods = $this->getCallbackMetadata($class, $cConfig['post_deserialize']);
            }
        }

        return $metadata;
    }

    protected function getExtension()
    {
        return 'yml';
    }

    private function addClassProperties(ClassMetadata $metadata, array $config)
    {
        if (isset($config['custom_accessor_order']) && !isset($config['accessor_order'])) {
            $config['accessor_order'] = 'custom';
        }

        if (isset($config['accessor_order'])) {
            $metadata->setAccessorOrder($config['accessor_order'], isset($config['custom_accessor_order']) ? $config['custom_accessor_order'] : array());
        }

        if (isset($config['xml_root_name'])) {
            $metadata->xmlRootName = (string)$config['xml_root_name'];
        }

        if (isset($config['xml_root_namespace'])) {
            $metadata->xmlRootNamespace = (string)$config['xml_root_namespace'];
        }

        if (array_key_exists('xml_namespaces', $config)) {

            foreach ($config['xml_namespaces'] as $prefix => $uri) {
                $metadata->registerNamespace($uri, $prefix);
            }

        }

        if (isset($config['discriminator'])) {
            if (isset($config['discriminator']['disabled']) && true === $config['discriminator']['disabled']) {
                $metadata->discriminatorDisabled = true;
            } else {
                if (!isset($config['discriminator']['field_name'])) {
                    throw new RuntimeException('The "field_name" attribute must be set for discriminators.');
                }

                if (!isset($config['discriminator']['map']) || !is_array($config['discriminator']['map'])) {
                    throw new RuntimeException('The "map" attribute must be set, and be an array for discriminators.');
                }
                $groups = isset($config['discriminator']['groups']) ? $config['discriminator']['groups'] : array();
                $metadata->setDiscriminator($config['discriminator']['field_name'], $config['discriminator']['map'], $groups);

                if (isset($config['discriminator']['xml_attribute'])) {
                    $metadata->xmlDiscriminatorAttribute = (bool)$config['discriminator']['xml_attribute'];
                }
                if (isset($config['discriminator']['xml_element'])) {
                    if (isset($config['discriminator']['xml_element']['cdata'])) {
                        $metadata->xmlDiscriminatorCData = (bool)$config['discriminator']['xml_element']['cdata'];
                    }
                    if (isset($config['discriminator']['xml_element']['namespace'])) {
                        $metadata->xmlDiscriminatorNamespace = (string)$config['discriminator']['xml_element']['namespace'];
                    }
                }

            }
        }
    }

    private function getCallbackMetadata(\ReflectionClass $class, $config)
    {
        if (is_string($config)) {
            $config = array($config);
        } elseif (!is_array($config)) {
            throw new RuntimeException(sprintf('callback methods expects a string, or an array of strings that represent method names, but got %s.', json_encode($config['pre_serialize'])));
        }

        $methods = array();
        foreach ($config as $name) {
            if (!$class->hasMethod($name)) {
                throw new RuntimeException(sprintf('The method %s does not exist in class %s.', $name, $class->name));
            }

            $methods[] = new MethodMetadata($class->name, $name);
        }

        return $methods;
    }
}


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 JMS\Serializer\Annotation\ExclusionPolicy;
22		use JMS\Serializer\Exception\RuntimeException;
23		use JMS\Serializer\GraphNavigator;
24		use JMS\Serializer\Metadata\ClassMetadata;
25		use JMS\Serializer\Metadata\ExpressionPropertyMetadata;
26		use JMS\Serializer\Metadata\PropertyMetadata;
27		use JMS\Serializer\Metadata\VirtualPropertyMetadata;
28		use Metadata\Driver\AbstractFileDriver;
29		use Metadata\MethodMetadata;
30		use Symfony\Component\Yaml\Yaml;
31
32		class YamlDriver extends AbstractFileDriver
33		{
34	26	protected function loadMetadataFromFile(\ReflectionClass $class, $file)
35		{
36	26	$config = Yaml::parse(file_get_contents($file));
37
38	26	if (!isset($config[$name = $class->name])) {
39		throw new RuntimeException(sprintf('Expected metadata for class %s to be defined in %s.', $class->name, $file));
40		}
41
42	26	$config = $config[$name];
43	26	$metadata = new ClassMetadata($name);
44	26	$metadata->fileResources[] = $file;
45	26	$metadata->fileResources[] = $class->getFileName();
46	26	$exclusionPolicy = isset($config['exclusion_policy']) ? strtoupper($config['exclusion_policy']) : 'NONE';
47	26	$excludeAll = isset($config['exclude']) ? (Boolean)$config['exclude'] : false;
48	26	$classAccessType = isset($config['access_type']) ? $config['access_type'] : PropertyMetadata::ACCESS_TYPE_PROPERTY;
49	26	$readOnlyClass = isset($config['read_only']) ? (Boolean)$config['read_only'] : false;
50	26	$this->addClassProperties($metadata, $config);
51
52	26	$propertiesMetadata = array();
53	26	if (array_key_exists('virtual_properties', $config)) {
54	4	foreach ($config['virtual_properties'] as $methodName => $propertySettings) {
55	4	if (isset($propertySettings['exp'])) {
56	2	$virtualPropertyMetadata = new ExpressionPropertyMetadata($name, $methodName, $propertySettings['exp']);
57	2	unset($propertySettings['exp']);
58
59	2	} else {
60
61	3	if (!$class->hasMethod($methodName)) {
62		throw new RuntimeException('The method ' . $methodName . ' not found in class ' . $class->name);
63		}
64	3	$virtualPropertyMetadata = new VirtualPropertyMetadata($name, $methodName);
65		}
66	4	$propertiesMetadata[$methodName] = $virtualPropertyMetadata;
67	4	$config['properties'][$methodName] = $propertySettings;
68	4	}
69	4	}
70
71	26	if (!$excludeAll) {
72	26	foreach ($class->getProperties() as $property) {
73	22	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...
74	2	continue;
75		}
76
77	21	$pName = $property->getName();
78	21	$propertiesMetadata[$pName] = new PropertyMetadata($name, $pName);
79	26	}
80
81	26	foreach ($propertiesMetadata as $pName => $pMetadata) {
82	23	$isExclude = false;
83		$isExpose = $pMetadata instanceof VirtualPropertyMetadata
84	23	\|\| $pMetadata instanceof ExpressionPropertyMetadata
85	23	\|\| (isset($config['properties']) && array_key_exists($pName, $config['properties']));
86
87	23	if (isset($config['properties'][$pName])) {
88	20	$pConfig = $config['properties'][$pName];
89
90	20	if (isset($pConfig['exclude'])) {
91	1	$isExclude = (Boolean)$pConfig['exclude'];
92	1	}
93
94	20	if (isset($pConfig['expose'])) {
95	3	$isExpose = (Boolean)$pConfig['expose'];
96	3	}
97
98	20	if (isset($pConfig['skip_when_empty'])) {
99	1	$pMetadata->skipWhenEmpty = (Boolean)$pConfig['skip_when_empty'];
100	1	}
101
102	20	if (isset($pConfig['since_version'])) {
103		$pMetadata->sinceVersion = (string)$pConfig['since_version'];
104		}
105
106	20	if (isset($pConfig['until_version'])) {
107		$pMetadata->untilVersion = (string)$pConfig['until_version'];
108		}
109
110	20	if (isset($pConfig['exclude_if'])) {
111	1	$pMetadata->excludeIf = (string)$pConfig['exclude_if'];
112	1	}
113
114	20	if (isset($pConfig['expose_if'])) {
115	1	$pMetadata->excludeIf = "!(" . $pConfig['expose_if'] . ")";
116	1	}
117
118	20	if (isset($pConfig['serialized_name'])) {
119	3	$pMetadata->serializedName = (string)$pConfig['serialized_name'];
120	3	}
121
122	20	if (isset($pConfig['type'])) {
123	15	$pMetadata->setType((string)$pConfig['type']);
124	15	}
125
126	20	if (isset($pConfig['deserializeType'])) {
127	1	$pMetadata->setDeserializeType((string)$pConfig['deserializeType']);
128	1	}
129
130	20	if (isset($pConfig['groups'])) {
131	1	$pMetadata->groups = $pConfig['groups'];
132	1	}
133
134	20	if (isset($pConfig['xml_list'])) {
135	2	$pMetadata->xmlCollection = true;
136
137	2	$colConfig = $pConfig['xml_list'];
138	2	if (isset($colConfig['inline'])) {
139	2	$pMetadata->xmlCollectionInline = (Boolean)$colConfig['inline'];
140	2	}
141
142	2	if (isset($colConfig['entry_name'])) {
143	1	$pMetadata->xmlEntryName = (string)$colConfig['entry_name'];
144	1	}
145
146	2	if (isset($colConfig['skip_when_empty'])) {
147	1	$pMetadata->xmlCollectionSkipWhenEmpty = (Boolean)$colConfig['skip_when_empty'];
148	1	} else {
149	2	$pMetadata->xmlCollectionSkipWhenEmpty = true;
150		}
151
152	2	if (isset($colConfig['namespace'])) {
153		$pMetadata->xmlEntryNamespace = (string)$colConfig['namespace'];
154		}
155	2	}
156
157	20	if (isset($pConfig['xml_map'])) {
158		$pMetadata->xmlCollection = true;
159
160		$colConfig = $pConfig['xml_map'];
161		if (isset($colConfig['inline'])) {
162		$pMetadata->xmlCollectionInline = (Boolean)$colConfig['inline'];
163		}
164
165		if (isset($colConfig['entry_name'])) {
166		$pMetadata->xmlEntryName = (string)$colConfig['entry_name'];
167		}
168
169		if (isset($colConfig['namespace'])) {
170		$pMetadata->xmlEntryNamespace = (string)$colConfig['namespace'];
171		}
172
173		if (isset($colConfig['key_attribute_name'])) {
174		$pMetadata->xmlKeyAttribute = $colConfig['key_attribute_name'];
175		}
176
177		}
178
179	20	if (isset($pConfig['xml_element'])) {
180	4	$colConfig = $pConfig['xml_element'];
181	4	if (isset($colConfig['cdata'])) {
182	2	$pMetadata->xmlElementCData = (Boolean)$colConfig['cdata'];
183	2	}
184
185	4	if (isset($colConfig['namespace'])) {
186	3	$pMetadata->xmlNamespace = (string)$colConfig['namespace'];
187	3	}
188	4	}
189
190	20	if (isset($pConfig['xml_attribute'])) {
191	4	$pMetadata->xmlAttribute = (Boolean)$pConfig['xml_attribute'];
192	4	}
193
194	20	if (isset($pConfig['xml_attribute_map'])) {
195		$pMetadata->xmlAttributeMap = (Boolean)$pConfig['xml_attribute_map'];
196		}
197
198	20	if (isset($pConfig['xml_value'])) {
199	2	$pMetadata->xmlValue = (Boolean)$pConfig['xml_value'];
200	2	}
201
202	20	if (isset($pConfig['xml_key_value_pairs'])) {
203	1	$pMetadata->xmlKeyValuePairs = (Boolean)$pConfig['xml_key_value_pairs'];
204	1	}
205
206		//we need read_only before setter and getter set, because that method depends on flag being set
207	20	if (isset($pConfig['read_only'])) {
208	1	$pMetadata->readOnly = (Boolean)$pConfig['read_only'];
209	1	} else {
210	19	$pMetadata->readOnly = $pMetadata->readOnly \|\| $readOnlyClass;
211		}
212
213	20	$pMetadata->setAccessor(
214	20	isset($pConfig['access_type']) ? $pConfig['access_type'] : $classAccessType,
215	20	isset($pConfig['accessor']['getter']) ? $pConfig['accessor']['getter'] : null,
216	20	isset($pConfig['accessor']['setter']) ? $pConfig['accessor']['setter'] : null
217	20	);
218
219	20	if (isset($pConfig['inline'])) {
220		$pMetadata->inline = (Boolean)$pConfig['inline'];
221		}
222
223	20	if (isset($pConfig['max_depth'])) {
224	1	$pMetadata->maxDepth = (int)$pConfig['max_depth'];
225	1	}
226	20	}
227	23	if ((ExclusionPolicy::NONE === $exclusionPolicy && !$isExclude)
228	6	\|\| (ExclusionPolicy::ALL === $exclusionPolicy && $isExpose)
229	23	) {
230	23	$metadata->addPropertyMetadata($pMetadata);
231	23	}
232	26	}
233	26	}
234
235	26	if (isset($config['handler_callbacks'])) {
236	1	foreach ($config['handler_callbacks'] as $directionName => $formats) {
237	1	$direction = GraphNavigator::parseDirection($directionName);
238	1	foreach ($formats as $format => $methodName) {
239	1	$metadata->addHandlerCallback($direction, $format, $methodName);
240	1	}
241	1	}
242	1	}
243
244	26	if (isset($config['callback_methods'])) {
245		$cConfig = $config['callback_methods'];
246
247		if (isset($cConfig['pre_serialize'])) {
248		$metadata->preSerializeMethods = $this->getCallbackMetadata($class, $cConfig['pre_serialize']);
249		}
250		if (isset($cConfig['post_serialize'])) {
251		$metadata->postSerializeMethods = $this->getCallbackMetadata($class, $cConfig['post_serialize']);
252		}
253		if (isset($cConfig['post_deserialize'])) {
254		$metadata->postDeserializeMethods = $this->getCallbackMetadata($class, $cConfig['post_deserialize']);
255		}
256		}
257
258	26	return $metadata;
259		}
260
261	26	protected function getExtension()
262		{
263	26	return 'yml';
264		}
265
266	26	private function addClassProperties(ClassMetadata $metadata, array $config)
267		{
268	26	if (isset($config['custom_accessor_order']) && !isset($config['accessor_order'])) {
269	1	$config['accessor_order'] = 'custom';
270	1	}
271
272	26	if (isset($config['accessor_order'])) {
273	1	$metadata->setAccessorOrder($config['accessor_order'], isset($config['custom_accessor_order']) ? $config['custom_accessor_order'] : array());
274	1	}
275
276	26	if (isset($config['xml_root_name'])) {
277	9	$metadata->xmlRootName = (string)$config['xml_root_name'];
278	9	}
279
280	26	if (isset($config['xml_root_namespace'])) {
281	1	$metadata->xmlRootNamespace = (string)$config['xml_root_namespace'];
282	1	}
283
284	26	if (array_key_exists('xml_namespaces', $config)) {
285
286	3	foreach ($config['xml_namespaces'] as $prefix => $uri) {
287	3	$metadata->registerNamespace($uri, $prefix);
288	3	}
289
290	3	}
291
292	26	if (isset($config['discriminator'])) {
293	4	if (isset($config['discriminator']['disabled']) && true === $config['discriminator']['disabled']) {
294		$metadata->discriminatorDisabled = true;
295		} else {
296	4	if (!isset($config['discriminator']['field_name'])) {
297		throw new RuntimeException('The "field_name" attribute must be set for discriminators.');
298		}
299
300	4	if (!isset($config['discriminator']['map']) \|\| !is_array($config['discriminator']['map'])) {
301		throw new RuntimeException('The "map" attribute must be set, and be an array for discriminators.');
302		}
303	4	$groups = isset($config['discriminator']['groups']) ? $config['discriminator']['groups'] : array();
304	4	$metadata->setDiscriminator($config['discriminator']['field_name'], $config['discriminator']['map'], $groups);
305
306	4	if (isset($config['discriminator']['xml_attribute'])) {
307	1	$metadata->xmlDiscriminatorAttribute = (bool)$config['discriminator']['xml_attribute'];
308	1	}
309	4	if (isset($config['discriminator']['xml_element'])) {
310	2	if (isset($config['discriminator']['xml_element']['cdata'])) {
311	1	$metadata->xmlDiscriminatorCData = (bool)$config['discriminator']['xml_element']['cdata'];
312	1	}
313	2	if (isset($config['discriminator']['xml_element']['namespace'])) {
314	1	$metadata->xmlDiscriminatorNamespace = (string)$config['discriminator']['xml_element']['namespace'];
315	1	}
316	2	}
317
318		}
319	4	}
320	26	}
321
322		private function getCallbackMetadata(\ReflectionClass $class, $config)
323		{
324		if (is_string($config)) {
325		$config = array($config);
326		} elseif (!is_array($config)) {
327		throw new RuntimeException(sprintf('callback methods expects a string, or an array of strings that represent method names, but got %s.', json_encode($config['pre_serialize'])));
328		}
329
330		$methods = array();
331		foreach ($config as $name) {
332		if (!$class->hasMethod($name)) {
333		throw new RuntimeException(sprintf('The method %s does not exist in class %s.', $name, $class->name));
334		}
335
336		$methods[] = new MethodMetadata($class->name, $name);
337		}
338
339		return $methods;
340		}
341		}
342

schmittjoh / serializer

Pull Request — master (#787)

YamlDriver::getExtension() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like