YamlDriver::getCallbackMetadata() - Code Metrics - Inspection of "Merge branch 'release-1.7'" - schmittjoh/serializer - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 0d7a9a...ac7eed )

by Asmir

created 2017-05-10 09:47 UTC

YamlDriver::getCallbackMetadata() B

↳ Parent: YamlDriver

Complexity

Conditions	5
Paths	7

Size

Total Lines	19
Code Lines	11

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	30

Importance

Changes

Metric	Value
dl	0
loc	19
ccs	0
cts	12
cp	0
rs	8.8571
c	0
b	0
f	0
cc	5
eloc	11
nc	7
nop	2
crap	30

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

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['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\GraphNavigator;
22		use JMS\Serializer\Exception\RuntimeException;
23		use JMS\Serializer\Annotation\ExclusionPolicy;
24		use JMS\Serializer\Metadata\ExpressionPropertyMetadata;
25		use Metadata\MethodMetadata;
26		use JMS\Serializer\Metadata\PropertyMetadata;
27		use JMS\Serializer\Metadata\VirtualPropertyMetadata;
28		use JMS\Serializer\Metadata\ClassMetadata;
29		use Symfony\Component\Yaml\Yaml;
30		use Metadata\Driver\AbstractFileDriver;
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['groups'])) {
127	1	$pMetadata->groups = $pConfig['groups'];
128	1	}
129
130	20	if (isset($pConfig['xml_list'])) {
131	2	$pMetadata->xmlCollection = true;
132
133	2	$colConfig = $pConfig['xml_list'];
134	2	if (isset($colConfig['inline'])) {
135	2	$pMetadata->xmlCollectionInline = (Boolean)$colConfig['inline'];
136	2	}
137
138	2	if (isset($colConfig['entry_name'])) {
139	1	$pMetadata->xmlEntryName = (string)$colConfig['entry_name'];
140	1	}
141
142	2	if (isset($colConfig['skip_when_empty'])) {
143	1	$pMetadata->xmlCollectionSkipWhenEmpty = (Boolean)$colConfig['skip_when_empty'];
144	1	} else {
145	2	$pMetadata->xmlCollectionSkipWhenEmpty = true;
146		}
147
148	2	if (isset($colConfig['namespace'])) {
149		$pMetadata->xmlEntryNamespace = (string) $colConfig['namespace'];
150		}
151	2	}
152
153	20	if (isset($pConfig['xml_map'])) {
154		$pMetadata->xmlCollection = true;
155
156		$colConfig = $pConfig['xml_map'];
157		if (isset($colConfig['inline'])) {
158		$pMetadata->xmlCollectionInline = (Boolean) $colConfig['inline'];
159		}
160
161		if (isset($colConfig['entry_name'])) {
162		$pMetadata->xmlEntryName = (string) $colConfig['entry_name'];
163		}
164
165		if (isset($colConfig['namespace'])) {
166		$pMetadata->xmlEntryNamespace = (string) $colConfig['namespace'];
167		}
168
169		if (isset($colConfig['key_attribute_name'])) {
170		$pMetadata->xmlKeyAttribute = $colConfig['key_attribute_name'];
171		}
172
173		}
174
175	20	if (isset($pConfig['xml_element'])) {
176	4	$colConfig = $pConfig['xml_element'];
177	4	if (isset($colConfig['cdata'])) {
178	2	$pMetadata->xmlElementCData = (Boolean) $colConfig['cdata'];
179	2	}
180
181	4	if (isset($colConfig['namespace'])) {
182	3	$pMetadata->xmlNamespace = (string) $colConfig['namespace'];
183	3	}
184	4	}
185
186	20	if (isset($pConfig['xml_attribute'])) {
187	4	$pMetadata->xmlAttribute = (Boolean) $pConfig['xml_attribute'];
188	4	}
189
190	20	if (isset($pConfig['xml_attribute_map'])) {
191		$pMetadata->xmlAttributeMap = (Boolean) $pConfig['xml_attribute_map'];
192		}
193
194	20	if (isset($pConfig['xml_value'])) {
195	2	$pMetadata->xmlValue = (Boolean) $pConfig['xml_value'];
196	2	}
197
198	20	if (isset($pConfig['xml_key_value_pairs'])) {
199	1	$pMetadata->xmlKeyValuePairs = (Boolean) $pConfig['xml_key_value_pairs'];
200	1	}
201
202		//we need read_only before setter and getter set, because that method depends on flag being set
203	20	if (isset($pConfig['read_only'])) {
204	1	$pMetadata->readOnly = (Boolean) $pConfig['read_only'];
205	1	} else {
206	19	$pMetadata->readOnly = $pMetadata->readOnly \|\| $readOnlyClass;
207		}
208
209	20	$pMetadata->setAccessor(
210	20	isset($pConfig['access_type']) ? $pConfig['access_type'] : $classAccessType,
211	20	isset($pConfig['accessor']['getter']) ? $pConfig['accessor']['getter'] : null,
212	20	isset($pConfig['accessor']['setter']) ? $pConfig['accessor']['setter'] : null
213	20	);
214
215	20	if (isset($pConfig['inline'])) {
216		$pMetadata->inline = (Boolean) $pConfig['inline'];
217		}
218
219	20	if (isset($pConfig['max_depth'])) {
220	1	$pMetadata->maxDepth = (int) $pConfig['max_depth'];
221	1	}
222	20	}
223	23	if ((ExclusionPolicy::NONE === $exclusionPolicy && ! $isExclude)
224	23	\|\| (ExclusionPolicy::ALL === $exclusionPolicy && $isExpose)) {
225	23	$metadata->addPropertyMetadata($pMetadata);
226	23	}
227	26	}
228	26	}
229
230	26	if (isset($config['handler_callbacks'])) {
231	1	foreach ($config['handler_callbacks'] as $directionName => $formats) {
232	1	$direction = GraphNavigator::parseDirection($directionName);
233	1	foreach ($formats as $format => $methodName) {
234	1	$metadata->addHandlerCallback($direction, $format, $methodName);
235	1	}
236	1	}
237	1	}
238
239	26	if (isset($config['callback_methods'])) {
240		$cConfig = $config['callback_methods'];
241
242		if (isset($cConfig['pre_serialize'])) {
243		$metadata->preSerializeMethods = $this->getCallbackMetadata($class, $cConfig['pre_serialize']);
244		}
245		if (isset($cConfig['post_serialize'])) {
246		$metadata->postSerializeMethods = $this->getCallbackMetadata($class, $cConfig['post_serialize']);
247		}
248		if (isset($cConfig['post_deserialize'])) {
249		$metadata->postDeserializeMethods = $this->getCallbackMetadata($class, $cConfig['post_deserialize']);
250		}
251		}
252
253	26	return $metadata;
254		}
255
256	26	protected function getExtension()
257		{
258	26	return 'yml';
259		}
260
261	26	private function addClassProperties(ClassMetadata $metadata, array $config)
262		{
263	26	if (isset($config['custom_accessor_order']) && ! isset($config['accessor_order'])) {
264	1	$config['accessor_order'] = 'custom';
265	1	}
266
267	26	if (isset($config['accessor_order'])) {
268	1	$metadata->setAccessorOrder($config['accessor_order'], isset($config['custom_accessor_order']) ? $config['custom_accessor_order'] : array());
269	1	}
270
271	26	if (isset($config['xml_root_name'])) {
272	9	$metadata->xmlRootName = (string) $config['xml_root_name'];
273	9	}
274
275	26	if (isset($config['xml_root_namespace'])) {
276	1	$metadata->xmlRootNamespace = (string) $config['xml_root_namespace'];
277	1	}
278
279	26	if (array_key_exists('xml_namespaces', $config)) {
280
281	3	foreach ($config['xml_namespaces'] as $prefix => $uri) {
282	3	$metadata->registerNamespace($uri, $prefix);
283	3	}
284
285	3	}
286
287	26	if (isset($config['discriminator'])) {
288	4	if (isset($config['discriminator']['disabled']) && true === $config['discriminator']['disabled']) {
289		$metadata->discriminatorDisabled = true;
290		} else {
291	4	if ( ! isset($config['discriminator']['field_name'])) {
292		throw new RuntimeException('The "field_name" attribute must be set for discriminators.');
293		}
294
295	4	if ( ! isset($config['discriminator']['map']) \|\| ! is_array($config['discriminator']['map'])) {
296		throw new RuntimeException('The "map" attribute must be set, and be an array for discriminators.');
297		}
298	4	$groups = isset($config['discriminator']['groups']) ? $config['discriminator']['groups'] : array();
299	4	$metadata->setDiscriminator($config['discriminator']['field_name'], $config['discriminator']['map'], $groups);
300
301	4	if (isset($config['discriminator']['xml_attribute'])) {
302	1	$metadata->xmlDiscriminatorAttribute = (bool) $config['discriminator']['xml_attribute'];
303	1	}
304	4	if (isset($config['discriminator']['xml_element'])) {
305	2	if (isset($config['discriminator']['xml_element']['cdata'])) {
306	1	$metadata->xmlDiscriminatorCData = (bool) $config['discriminator']['xml_element']['cdata'];
307	1	}
308	2	if (isset($config['discriminator']['xml_element']['namespace'])) {
309	1	$metadata->xmlDiscriminatorNamespace = (string) $config['discriminator']['xml_element']['namespace'];
310	1	}
311	2	}
312
313		}
314	4	}
315	26	}
316
317		private function getCallbackMetadata(\ReflectionClass $class, $config)
318		{
319		if (is_string($config)) {
320		$config = array($config);
321		} elseif ( ! is_array($config)) {
322		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'])));
323		}
324
325		$methods = array();
326		foreach ($config as $name) {
327		if ( ! $class->hasMethod($name)) {
328		throw new RuntimeException(sprintf('The method %s does not exist in class %s.', $name, $class->name));
329		}
330
331		$methods[] = new MethodMetadata($class->name, $name);
332		}
333
334		return $methods;
335		}
336		}
337

schmittjoh / serializer

Push — master ( 0d7a9a...ac7eed )

YamlDriver::getCallbackMetadata() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like