diogo
/
symfony
Archived
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

merged branch beberlei/SerializerOptions (PR #6797) 

This PR was merged into the master branch.

Commits
-------

fcabadf Fix JsonDecode to work on PHP 5.3, update the CHANGELOG.md
b6bdb45 Completly refactor the Serializer Options Pull Request to push context information directly and avoid state and dependencies between SerializerInterface and encoders/normalizers.
ef652e2 Added context to JsonEncoder
eacb7e2 Rename $options to $context, as it makes the intent much more clear.
8854b85 Fix CS issues, removed global options
9c54a4b [Serializer] Allow options to be passed to SerialiizerInterface#serialize and #unserialize. Thsee options are available to all encoders/decoders/normalizers that implement SerializerAwareInterface.

Discussion
----------

[2.2] [Serializer] Configurable Serializer

Bug fix: no
Feature addition: yes
Backwards compatibility break: yes
Symfony2 tests pass: yes
Fixes the following tickets: #4907, #4938
License of the code: MIT
Todo:

This is an extension of GH-6574 that removes the context state in favor of passing this information around.

---------------------------------------------------------------------------

by beberlei at 2013-01-18T13:12:39Z

@fabpot @lsmith I think this is how it should work from an OOP/OOD perpesctive, avoiding the context state. This makes for a much cleaner code and dependency graph.

---------------------------------------------------------------------------

by lsmith77 at 2013-01-18T14:14:37Z

makes sense. anything fancier would lose this components simplicity which IMHO is the main benefit versus JMS serializer.

---------------------------------------------------------------------------

by fabpot at 2013-01-18T14:26:25Z

Looks very good. 👍

---------------------------------------------------------------------------

by beberlei at 2013-01-18T14:37:32Z

I need to fix the failures with the JsonEncoder and then this is good to merge

---------------------------------------------------------------------------

by stof at 2013-01-18T14:40:21Z

you also need to update the CHANGELOG of the component

---------------------------------------------------------------------------

by beberlei at 2013-01-18T23:17:57Z

Fixed, only the Redis Profiler problem still failing the Travis builds. Also I updated the CHANGELOG.md.

@fabpot  Good to merge from my POV

---------------------------------------------------------------------------

by stof at 2013-01-18T23:27:59Z

@beberlei see #6804 for the Redis profiler issue
This commit is contained in:
Fabien Potencier 2013-01-19 08:48:06 +01:00
parent c9cfcc1dc3 fcabadfc23
commit 62a4cc90cc
24 changed files with 262 additions and 73 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
UPGRADE-2.2.md
View File

@ -562,3 +562,9 @@
framework:
trusted_proxies: ['127.0.0.1', '10.0.0.1'] # a list of proxy IPs you trust
```
#### Serializer
* All serializer interfaces (Serializer, Normalizer, Encoder) have been extended with an optional ``$context`` array.
This was necessary to allow for more complex use-cases that require context information during the (de)normalization
and en-/decoding steps.

10
src/Symfony/Component/Serializer/CHANGELOG.md
View File

@ -1,6 +1,16 @@
CHANGELOG
=========
2.2.0
-----
* All Serializer, Normalizer and Encoder interfaces have been
modified to include an optional ``$context`` array parameter.
* The XML Root name can now be configured with the ``xml_root_name``
parameter in the context option to the ``XmlEncoder``.
* Options to ``json_encode`` and ``json_decode`` can be passed through
the context options of ``JsonEncode`` and ``JsonDecode`` encoder/decoders.
2.1.0
-----

4
src/Symfony/Component/Serializer/Encoder/ChainDecoder.php
View File

@ -34,9 +34,9 @@ class ChainDecoder implements DecoderInterface
/**
* {@inheritdoc}
*/
final public function decode($data, $format)
final public function decode($data, $format, array $context = array())
{
return $this->getDecoder($format)->decode($data, $format);
return $this->getDecoder($format)->decode($data, $format, $context);
}
/**

4
src/Symfony/Component/Serializer/Encoder/ChainEncoder.php
View File

@ -35,9 +35,9 @@ class ChainEncoder implements EncoderInterface
/**
* {@inheritdoc}
*/
final public function encode($data, $format)
final public function encode($data, $format, array $context = array())
{
return $this->getEncoder($format)->encode($data, $format);
return $this->getEncoder($format)->encode($data, $format, $context);
}
/**

3
src/Symfony/Component/Serializer/Encoder/DecoderInterface.php
View File

@ -23,10 +23,11 @@ interface DecoderInterface
*
* @param scalar $data Data to decode
* @param string $format Format name
* @param array $context options that decoders have access to.
*
* @return mixed
*/
public function decode($data, $format);
public function decode($data, $format, array $context = array());
/**
* Checks whether the serializer can decode from given format

3
src/Symfony/Component/Serializer/Encoder/EncoderInterface.php
View File

@ -23,10 +23,11 @@ interface EncoderInterface
*
* @param mixed $data Data to encode
* @param string $format Format name
* @param array $context options that normalizers/encoders have access to.
*
* @return scalar
*/
public function encode($data, $format);
public function encode($data, $format, array $context = array());
/**
* Checks whether the serializer can encode to given format

33
src/Symfony/Component/Serializer/Encoder/JsonDecode.php
View File

@ -21,6 +21,7 @@ class JsonDecode implements DecoderInterface
private $associative;
private $recursionDepth;
private $lastError = JSON_ERROR_NONE;
protected $serializer;
public function __construct($associative = false, $depth = 512)
{
@ -48,9 +49,20 @@ class JsonDecode implements DecoderInterface
*
* @return mixed
*/
public function decode($data, $format)
public function decode($data, $format, array $context = array())
{
$decodedData = json_decode($data, $this->associative, $this->recursionDepth);
$context = $this->resolveContext($context);
$associative = $context['json_decode_associative'];
$recursionDepth = $context['json_decode_recursion_depth'];
$options = $context['json_decode_options'];
if (version_compare(PHP_VERSION, '5.4.0') >= 0) {
$decodedData = json_decode($data, $associative, $recursionDepth, $options);
} else {
$decodedData = json_decode($data, $associative, $recursionDepth);
}
$this->lastError = json_last_error();
return $decodedData;
@ -63,4 +75,21 @@ class JsonDecode implements DecoderInterface
{
return JsonEncoder::FORMAT === $format;
}
/**
* Merge the default options of the Json Decoder with the passed context.
*
* @param array $context
* @return array
*/
private function resolveContext(array $context)
{
$defaultOptions = array(
'json_decode_associative' => $this->associative,
'json_decode_recursion_depth' => $this->recursionDepth,
'json_decode_options' => 0
);
return array_merge($defaultOptions, $context);
}
}

22
src/Symfony/Component/Serializer/Encoder/JsonEncode.php
View File

@ -41,14 +41,13 @@ class JsonEncode implements EncoderInterface
/**
* Encodes PHP data to a JSON string
*
* @param mixed $data
* @param string $format
*
* @return string
* {@inheritdoc}
*/
public function encode($data, $format)
public function encode($data, $format, array $context = array())
{
$encodedJson = json_encode($data, $this->options);
$context = $this->resolveContext($context);
$encodedJson = json_encode($data, $context['json_encode_options']);
$this->lastError = json_last_error();
return $encodedJson;
@ -61,4 +60,15 @@ class JsonEncode implements EncoderInterface
{
return JsonEncoder::FORMAT === $format;
}
/**
* Merge default json encode options with context.
*
* @param array $context
* @return array
*/
private function resolveContext(array $context = array())
{
return array_merge(array('json_encode_options' => $this->options), $context);
}
}

8
src/Symfony/Component/Serializer/Encoder/JsonEncoder.php
View File

@ -59,17 +59,17 @@ class JsonEncoder implements EncoderInterface, DecoderInterface
/**
* {@inheritdoc}
*/
public function encode($data, $format)
public function encode($data, $format, array $context = array())
{
return $this->encodingImpl->encode($data, self::FORMAT);
return $this->encodingImpl->encode($data, self::FORMAT, $context);
}
/**
* {@inheritdoc}
*/
public function decode($data, $format)
public function decode($data, $format, array $context = array())
{
return $this->decodingImpl->decode($data, self::FORMAT);
return $this->decodingImpl->decode($data, self::FORMAT, $context);
}
/**

45
src/Symfony/Component/Serializer/Encoder/XmlEncoder.php
View File

@ -26,24 +26,36 @@ class XmlEncoder extends SerializerAwareEncoder implements EncoderInterface, Dec
private $format;
private $rootNodeName = 'response';
/**
* Construct new XmlEncoder and allow to change the root node element name.
*
* @param string $rootNodeName
*/
public function __construct($rootNodeName = 'response')
{
$this->rootNodeName = $rootNodeName;
}
/**
* {@inheritdoc}
*/
public function encode($data, $format)
public function encode($data, $format, array $context = array())
{
if ($data instanceof \DOMDocument) {
return $data->saveXML();
}
$xmlRootNodeName = $this->resolveXmlRootName($context);
$this->dom = new \DOMDocument();
$this->format = $format;
if (null !== $data && !is_scalar($data)) {
$root = $this->dom->createElement($this->rootNodeName);
$root = $this->dom->createElement($xmlRootNodeName);
$this->dom->appendChild($root);
$this->buildXml($root, $data);
$this->buildXml($root, $data, $xmlRootNodeName);
} else {
$this->appendNode($this->dom, $data, $this->rootNodeName);
$this->appendNode($this->dom, $data, $xmlRootNodeName);
}
return $this->dom->saveXML();
@ -52,7 +64,7 @@ class XmlEncoder extends SerializerAwareEncoder implements EncoderInterface, Dec
/**
* {@inheritdoc}
*/
public function decode($data, $format)
public function decode($data, $format, array $context = array())
{
$internalErrors = libxml_use_internal_errors(true);
$disableEntities = libxml_disable_entity_loader(true);
@ -269,12 +281,13 @@ class XmlEncoder extends SerializerAwareEncoder implements EncoderInterface, Dec
*
* @param DOMNode $parentNode
* @param array|object $data data
* @param string $xmlRootNodeName
*
* @return Boolean
*
* @throws UnexpectedValueException
*/
private function buildXml($parentNode, $data)
private function buildXml($parentNode, $data, $xmlRootNodeName)
{
$append = true;
@ -310,21 +323,24 @@ class XmlEncoder extends SerializerAwareEncoder implements EncoderInterface, Dec
return $append;
}
if (is_object($data)) {
$data = $this->serializer->normalize($data, $this->format);
if (null !== $data && !is_scalar($data)) {
return $this->buildXml($parentNode, $data);
return $this->buildXml($parentNode, $data, $xmlRootNodeName);
}
// top level data object was normalized into a scalar
if (!$parentNode->parentNode->parentNode) {
$root = $parentNode->parentNode;
$root->removeChild($parentNode);
return $this->appendNode($root, $data, $this->rootNodeName);
return $this->appendNode($root, $data, $xmlRootNodeName);
}
return $this->appendNode($parentNode, $data, 'data');
}
throw new UnexpectedValueException('An unexpected value could not be serialized: '.var_export($data, true));
}
@ -376,7 +392,7 @@ class XmlEncoder extends SerializerAwareEncoder implements EncoderInterface, Dec
private function selectNodeType($node, $val)
{
if (is_array($val)) {
return $this->buildXml($node, $val);
return $this->buildXml($node, $val, null);
} elseif ($val instanceof \SimpleXMLElement) {
$child = $this->dom->importNode(dom_import_simplexml($val), true);
$node->appendChild($child);
@ -399,4 +415,15 @@ class XmlEncoder extends SerializerAwareEncoder implements EncoderInterface, Dec
return true;
}
/**
* Get real XML root node name, taking serializer options into account.
*/
private function resolveXmlRootName(array $context = array())
{
return isset($context['xml_root_node_name'])
? $context['xml_root_node_name']
: $this->rootNodeName;
}
}

8
src/Symfony/Component/Serializer/Normalizer/CustomNormalizer.php
View File

@ -19,18 +19,18 @@ class CustomNormalizer extends SerializerAwareNormalizer implements NormalizerIn
/**
* {@inheritdoc}
*/
public function normalize($object, $format = null)
public function normalize($object, $format = null, array $context = array())
{
return $object->normalize($this->serializer, $format);
return $object->normalize($this->serializer, $format, $context);
}
/**
* {@inheritdoc}
*/
public function denormalize($data, $class, $format = null)
public function denormalize($data, $class, $format = null, array $context = array())
{
$object = new $class;
$object->denormalize($this->serializer, $data, $format);
$object->denormalize($this->serializer, $data, $format, $context);
return $object;
}

3
src/Symfony/Component/Serializer/Normalizer/DenormalizableInterface.php
View File

@ -32,6 +32,7 @@ interface DenormalizableInterface
* @param array|scalar $data The data from which to re-create the object.
* @param string|null $format The format is optionally given to be able to denormalize differently
* based on different input formats.
* @param array $context options for denormalizing
*/
public function denormalize(DenormalizerInterface $denormalizer, $data, $format = null);
public function denormalize(DenormalizerInterface $denormalizer, $data, $format = null, array $context = array());
}

3
src/Symfony/Component/Serializer/Normalizer/DenormalizerInterface.php
View File

@ -24,10 +24,11 @@ interface DenormalizerInterface
* @param mixed $data data to restore
* @param string $class the expected class to instantiate
* @param string $format format the given data was extracted from
* @param array $context options available to the denormalizer
*
* @return object
*/
public function denormalize($data, $class, $format = null);
public function denormalize($data, $class, $format = null, array $context = array());
/**
* Checks whether the given class is supported for denormalization by this normalizer

4
src/Symfony/Component/Serializer/Normalizer/GetSetMethodNormalizer.php
View File

@ -69,7 +69,7 @@ class GetSetMethodNormalizer extends SerializerAwareNormalizer implements Normal
/**
* {@inheritdoc}
*/
public function normalize($object, $format = null)
public function normalize($object, $format = null, array $context = array())
{
$reflectionObject = new \ReflectionObject($object);
$reflectionMethods = $reflectionObject->getMethods(\ReflectionMethod::IS_PUBLIC);
@ -101,7 +101,7 @@ class GetSetMethodNormalizer extends SerializerAwareNormalizer implements Normal
/**
* {@inheritdoc}
*/
public function denormalize($data, $class, $format = null)
public function denormalize($data, $class, $format = null, array $context = array())
{
$reflectionClass = new \ReflectionClass($class);
$constructor = $reflectionClass->getConstructor();

3
src/Symfony/Component/Serializer/Normalizer/NormalizableInterface.php
View File

@ -31,8 +31,9 @@ interface NormalizableInterface
* can use it to normalize objects contained within this object.
* @param string|null $format The format is optionally given to be able to normalize differently
* based on different output formats.
* @param array $context Options for normalizing this object
*
* @return array|scalar
*/
public function normalize(NormalizerInterface $normalizer, $format = null);
public function normalize(NormalizerInterface $normalizer, $format = null, array $context = array());
}

3
src/Symfony/Component/Serializer/Normalizer/NormalizerInterface.php
View File

@ -23,10 +23,11 @@ interface NormalizerInterface
*
* @param object $object object to normalize
* @param string $format format the normalization result will be encoded as
* @param array $context Context options for the normalizer
*
* @return array|scalar
*/
public function normalize($object, $format = null);
public function normalize($object, $format = null, array $context = array());
/**
* Checks whether the given class is supported for normalization by this normalizer

52
src/Symfony/Component/Serializer/Serializer.php
View File

@ -39,8 +39,8 @@ class Serializer implements SerializerInterface, NormalizerInterface, Denormaliz
{
protected $encoder;
protected $decoder;
protected $normalizers = array();
protected $normalizerCache = array();
protected $normalizers = array();
protected $normalizerCache = array();
protected $denormalizerCache = array();
public function __construct(array $normalizers = array(), array $encoders = array())
@ -72,58 +72,58 @@ class Serializer implements SerializerInterface, NormalizerInterface, Denormaliz
/**
* {@inheritdoc}
*/
final public function serialize($data, $format)
final public function serialize($data, $format, array $context = array())
{
if (!$this->supportsEncoding($format)) {
throw new UnexpectedValueException('Serialization for the format '.$format.' is not supported');
}
if ($this->encoder->needsNormalization($format)) {
$data = $this->normalize($data, $format);
$data = $this->normalize($data, $format, $context);
}
return $this->encode($data, $format);
return $this->encode($data, $format, $context);
}
/**
* {@inheritdoc}
*/
final public function deserialize($data, $type, $format)
final public function deserialize($data, $type, $format, array $context = array())
{
if (!$this->supportsDecoding($format)) {
throw new UnexpectedValueException('Deserialization for the format '.$format.' is not supported');
}
$data = $this->decode($data, $format);
$data = $this->decode($data, $format, $context);
return $this->denormalize($data, $type, $format);
return $this->denormalize($data, $type, $format, $context);
}
/**
* {@inheritdoc}
*/
public function normalize($data, $format = null)
public function normalize($data, $format = null, array $context = array())
{
if (null === $data || is_scalar($data)) {
return $data;
}
if (is_object($data) && $this->supportsNormalization($data, $format)) {
return $this->normalizeObject($data, $format);
return $this->normalizeObject($data, $format, $context);
}
if ($data instanceof \Traversable) {
$normalized = array();
foreach ($data as $key => $val) {
$normalized[$key] = $this->normalize($val, $format);
$normalized[$key] = $this->normalize($val, $format, $context);
}
return $normalized;
}
if (is_object($data)) {
return $this->normalizeObject($data, $format);
return $this->normalizeObject($data, $format, $context);
}
if (is_array($data)) {
foreach ($data as $key => $val) {
$data[$key] = $this->normalize($val, $format);
$data[$key] = $this->normalize($val, $format, $context);
}
return $data;
@ -134,9 +134,9 @@ class Serializer implements SerializerInterface, NormalizerInterface, Denormaliz
/**
* {@inheritdoc}
*/
public function denormalize($data, $type, $format = null)
public function denormalize($data, $type, $format = null, array $context = array())
{
return $this->denormalizeObject($data, $type, $format);
return $this->denormalizeObject($data, $type, $format, $context);
}
/**
@ -202,17 +202,17 @@ class Serializer implements SerializerInterface, NormalizerInterface, Denormaliz
/**
* {@inheritdoc}
*/
final public function encode($data, $format)
final public function encode($data, $format, array $context = array())
{
return $this->encoder->encode($data, $format);
return $this->encoder->encode($data, $format, $context);
}
/**
* {@inheritdoc}
*/
final public function decode($data, $format)
final public function decode($data, $format, array $context = array())
{
return $this->decoder->decode($data, $format);
return $this->decoder->decode($data, $format, $context);
}
/**
@ -220,13 +220,14 @@ class Serializer implements SerializerInterface, NormalizerInterface, Denormaliz
*
* @param object $object object to normalize
* @param string $format format name, present to give the option to normalizers to act differently based on formats
* @param array $context The context data for this particular normalization
*
* @return array|scalar
*
* @throws LogicException
* @throws UnexpectedValueException
*/
private function normalizeObject($object, $format = null)
private function normalizeObject($object, $format = null, array $context = array())
{
if (!$this->normalizers) {
throw new LogicException('You must register at least one normalizer to be able to normalize objects.');
@ -234,14 +235,14 @@ class Serializer implements SerializerInterface, NormalizerInterface, Denormaliz
$class = get_class($object);
if (isset($this->normalizerCache[$class][$format])) {
return $this->normalizerCache[$class][$format]->normalize($object, $format);
return $this->normalizerCache[$class][$format]->normalize($object, $format, $context);
}
foreach ($this->normalizers as $normalizer) {
if ($normalizer->supportsNormalization($object, $format)) {
$this->normalizerCache[$class][$format] = $normalizer;
return $normalizer->normalize($object, $format);
return $normalizer->normalize($object, $format, $context);
}
}
@ -254,27 +255,28 @@ class Serializer implements SerializerInterface, NormalizerInterface, Denormaliz
* @param mixed $data data to restore
* @param string $class the expected class to instantiate
* @param string $format format name, present to give the option to normalizers to act differently based on formats
* @param array $context The context data for this particular denormalization
*
* @return object
*
* @throws LogicException
* @throws UnexpectedValueException
*/
private function denormalizeObject($data, $class, $format = null)
private function denormalizeObject($data, $class, $format = null, array $context = array())
{
if (!$this->normalizers) {
throw new LogicException('You must register at least one normalizer to be able to denormalize objects.');
}
if (isset($this->denormalizerCache[$class][$format])) {
return $this->denormalizerCache[$class][$format]->denormalize($data, $class, $format);
return $this->denormalizerCache[$class][$format]->denormalize($data, $class, $format, $context);
}
foreach ($this->normalizers as $normalizer) {
if ($normalizer->supportsDenormalization($data, $class, $format)) {
$this->denormalizerCache[$class][$format] = $normalizer;
return $normalizer->denormalize($data, $class, $format);
return $normalizer->denormalize($data, $class, $format, $context);
}
}

10
src/Symfony/Component/Serializer/SerializerInterface.php
View File

@ -21,12 +21,13 @@ interface SerializerInterface
/**
* Serializes data in the appropriate format
*
* @param mixed $data any data
* @param string $format format name
* @param mixed $data any data
* @param string $format format name
* @param array $context options normalizers/encoders have access to
*
* @return string
*/
public function serialize($data, $format);
public function serialize($data, $format, array $context = array());
/**
* Deserializes data into the given type.
@ -34,8 +35,9 @@ interface SerializerInterface
* @param mixed $data
* @param string $type
* @param string $format
* @param array $context
*
* @return object
*/
public function deserialize($data, $type, $format);
public function deserialize($data, $type, $format, array $context = array());
}

80
src/Symfony/Component/Serializer/Tests/Encoder/JsonEncoderTest.php Normal file
View File

@ -0,0 +1,80 @@
<?php
/*
* This file is part of the Symfony package.
*
* (c) Fabien Potencier <fabien@symfony.com>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\Serializer\Tests\Encoder;
use Symfony\Component\Serializer\Encoder\JsonEncoder;
use Symfony\Component\Serializer\Serializer;
use Symfony\Component\Serializer\Normalizer\CustomNormalizer;
class JsonEncoderTest extends \PHPUnit_Framework_TestCase
{
protected function setUp()
{
$this->encoder = new JsonEncoder;
$this->serializer = new Serializer(array(new CustomNormalizer()), array('json' => new JsonEncoder()));
}
public function testEncodeScalar()
{
$obj = new \stdClass;
$obj->foo = "foo";
$expected = '{"foo":"foo"}';
$this->assertEquals($expected, $this->encoder->encode($obj, 'json'));
}
public function testComplexObject()
{
$obj = $this->getObject();
$expected = $this->getJsonSource();
$this->assertEquals($expected, $this->encoder->encode($obj, 'json'));
}
public function testOptions()
{
$context = array('json_encode_options' => JSON_NUMERIC_CHECK);
$arr = array();
$arr['foo'] = "3";
$expected = '{"foo":3}';
$this->assertEquals($expected, $this->serializer->serialize($arr, 'json', $context));
$arr = array();
$arr['foo'] = "3";
$expected = '{"foo":"3"}';
$this->assertEquals($expected, $this->serializer->serialize($arr, 'json'), 'Context should not be persistent');
}
protected function getJsonSource()
{
return '{"foo":"foo","bar":["a","b"],"baz":{"key":"val","key2":"val","A B":"bar","item":[{"title":"title1"},{"title":"title2"}],"Barry":{"FooBar":{"Baz":"Ed","@id":1}}},"qux":"1"}';
}
protected function getObject()
{
$obj = new \stdClass;
$obj->foo = 'foo';
$obj->bar = array('a', 'b');
$obj->baz = array('key' => 'val', 'key2' => 'val', 'A B' => 'bar', 'item' => array(array('title' => 'title1'), array('title' => 'title2')), 'Barry' => array('FooBar' => array('Baz' => 'Ed', '@id' => 1)));
$obj->qux = "1";
return $obj;
}
}

17
src/Symfony/Component/Serializer/Tests/Encoder/XmlEncoderTest.php
View File

@ -184,6 +184,23 @@ class XmlEncoderTest extends \PHPUnit_Framework_TestCase
$this->assertEquals($source, $this->encoder->encode($obj, 'xml'));
}
public function testEncodeSerializerXmlRootNodeNameOption()
{
$options = array('xml_root_node_name' => 'test');
$this->encoder = new XmlEncoder;
$serializer = new Serializer(array(), array('xml' => new XmlEncoder()));
$this->encoder->setSerializer($serializer);
$array = array(
'person' => array('@gender' => 'M', '#' => 'Peter'),
);
$expected = '<?xml version="1.0"?>'."\n".
'<test><person gender="M">Peter</person></test>'."\n";
$this->assertEquals($expected, $serializer->serialize($array, 'xml', $options));
}
public function testDecode()
{
$source = $this->getXmlSource();

2
src/Symfony/Component/Serializer/Tests/Fixtures/DenormalizableDummy.php
View File

@ -17,7 +17,7 @@ use Symfony\Component\Serializer\Normalizer\DenormalizerInterface;
class DenormalizableDummy implements DenormalizableInterface
{
public function denormalize(DenormalizerInterface $denormalizer, $data, $format = null)
public function denormalize(DenormalizerInterface $denormalizer, $data, $format = null, array $context = array())
{
}

4
src/Symfony/Component/Serializer/Tests/Fixtures/Dummy.php
View File

@ -23,7 +23,7 @@ class Dummy implements NormalizableInterface, DenormalizableInterface
public $baz;
public $qux;
public function normalize(NormalizerInterface $normalizer, $format = null)
public function normalize(NormalizerInterface $normalizer, $format = null, array $context = array())
{
return array(
'foo' => $this->foo,
@ -33,7 +33,7 @@ class Dummy implements NormalizableInterface, DenormalizableInterface
);
}
public function denormalize(DenormalizerInterface $denormalizer, $data, $format = null)
public function denormalize(DenormalizerInterface $denormalizer, $data, $format = null, array $context = array())
{
$this->foo = $data['foo'];
$this->bar = $data['bar'];

4
src/Symfony/Component/Serializer/Tests/Fixtures/NormalizableTraversableDummy.php
View File

@ -18,7 +18,7 @@ use Symfony\Component\Serializer\Normalizer\DenormalizerInterface;
class NormalizableTraversableDummy extends TraversableDummy implements NormalizableInterface, DenormalizableInterface
{
public function normalize(NormalizerInterface $normalizer, $format = null)
public function normalize(NormalizerInterface $normalizer, $format = null, array $context = array())
{
return array(
'foo' => 'normalizedFoo',
@ -26,7 +26,7 @@ class NormalizableTraversableDummy extends TraversableDummy implements Normaliza
);
}
public function denormalize(DenormalizerInterface $denormalizer, $data, $format = null)
public function denormalize(DenormalizerInterface $denormalizer, $data, $format = null, array $context = array())
{
return array(
'foo' => 'denormalizedFoo',

4
src/Symfony/Component/Serializer/Tests/Fixtures/ScalarDummy.php
View File

@ -21,12 +21,12 @@ class ScalarDummy implements NormalizableInterface, DenormalizableInterface
public $foo;
public $xmlFoo;
public function normalize(NormalizerInterface $normalizer, $format = null)
public function normalize(NormalizerInterface $normalizer, $format = null, array $context = array())
{
return $format === 'xml' ? $this->xmlFoo : $this->foo;
}
public function denormalize(DenormalizerInterface $denormalizer, $data, $format = null)
public function denormalize(DenormalizerInterface $denormalizer, $data, $format = null, array $context = array())
{
if ($format === 'xml') {
$this->xmlFoo = $data;