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

merged Seldaek/serializer_fix

Browse Source
This commit is contained in:
Fabien Potencier 2011-05-11 10:16:15 +02:00
commit 9abd53c2b4
18 changed files with 208 additions and 172 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
UPDATE.md
View File

@ -134,6 +134,11 @@ beta1 to beta2
* ParameterBag::getDeep() has been removed, and is replaced with a boolean flag
on the ParameterBag::get() method.
* Serializer: `AbstractEncoder` & `AbstractNormalizer` were renamed to
`SerializerAwareEncoder` & `SerializerAwareNormalizer`.
* Serializer: The `$properties` argument has been dropped from all interfaces.
PR12 to beta1
-------------

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

@ -14,7 +14,7 @@ use Symfony\Component\Serializer\SerializerInterface;
*/
/**
* Defines the interface of encoders
* Defines the interface of encoders that are able to decode their own format
*
* @author Jordi Boggiano <j.boggiano@seld.be>
*/

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

@ -18,16 +18,13 @@ use Symfony\Component\Serializer\SerializerInterface;
*
* @author Jordi Boggiano <j.boggiano@seld.be>
*/
class JsonEncoder extends AbstractEncoder implements DecoderInterface
class JsonEncoder implements EncoderInterface, DecoderInterface
{
/**
* {@inheritdoc}
*/
public function encode($data, $format)
{
if ($this->serializer->isStructuredType($data)) {
$data = $this->serializer->normalize($data, $format);
}
return json_encode($data);
}

26
src/Symfony/Component/Serializer/Encoder/NormalizationAwareInterface.php Executable file
View File

@ -0,0 +1,26 @@
<?php
namespace Symfony\Component\Serializer\Encoder;
use Symfony\Component\Serializer\SerializerInterface;
/*
* This file is part of the Symfony framework.
*
* (c) Fabien Potencier <fabien@symfony.com>
*
* This source file is subject to the MIT license that is bundled
* with this source code in the file LICENSE.
*/
/**
* Defines the interface of encoders that will normalize data themselves
*
* Implementing this interface essentially just tells the Serializer that the
* data should not be pre-normalized before being passed to this Encoder.
*
* @author Jordi Boggiano <j.boggiano@seld.be>
*/
interface NormalizationAwareInterface
{
}

12
src/Symfony/Component/Serializer/Encoder/AbstractEncoder.php → src/Symfony/Component/Serializer/Encoder/SerializerAwareEncoder.php
View File

@ -15,11 +15,11 @@ use Symfony\Component\Serializer\SerializerAwareInterface;
*/
/**
* Abstract Encoder implementation
* SerializerAware Encoder implementation
*
* @author Jordi Boggiano <j.boggiano@seld.be>
*/
abstract class AbstractEncoder implements SerializerAwareInterface, EncoderInterface
abstract class SerializerAwareEncoder implements SerializerAwareInterface, EncoderInterface
{
protected $serializer;
@ -30,12 +30,4 @@ abstract class AbstractEncoder implements SerializerAwareInterface, EncoderInter
{
$this->serializer = $serializer;
}
/**
* {@inheritdoc}
*/
public function getSerializer()
{
return $this->serializer;
}
}

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

@ -20,7 +20,7 @@ use Symfony\Component\Serializer\SerializerInterface;
* @author John Wards <jwards@whiteoctober.co.uk>
* @author Fabian Vogler <fabian@equivalence.ch>
*/
class XmlEncoder extends AbstractEncoder implements DecoderInterface
class XmlEncoder extends SerializerAwareEncoder implements DecoderInterface, NormalizationAwareInterface
{
private $dom;
private $format;
@ -38,7 +38,7 @@ class XmlEncoder extends AbstractEncoder implements DecoderInterface
$this->dom = new \DOMDocument();
$this->format = $format;
if ($this->serializer->isStructuredType($data)) {
if (null !== $data && !is_scalar($data)) {
$root = $this->dom->createElement($this->rootNodeName);
$this->dom->appendChild($root);
$this->buildXml($root, $data);
@ -248,16 +248,16 @@ class XmlEncoder extends AbstractEncoder implements DecoderInterface
}
if (is_object($data)) {
$data = $this->serializer->normalizeObject($data, $this->format);
if (!$this->serializer->isStructuredType($data)) {
// top level data object is normalized into a scalar
if (!$parentNode->parentNode->parentNode) {
$root = $parentNode->parentNode;
$root->removeChild($parentNode);
return $this->appendNode($root, $data, $this->rootNodeName);
}
return $this->appendNode($parentNode, $data, 'data');
if (null !== $data && !is_scalar($data)) {
return $this->buildXml($parentNode, $data);
}
return $this->buildXml($parentNode, $data);
// 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($parentNode, $data, 'data');
}
throw new \UnexpectedValueException('An unexpected value could not be serialized: '.var_export($data, true));
}

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

@ -16,14 +16,14 @@ use Symfony\Component\Serializer\SerializerInterface;
/**
* @author Jordi Boggiano <j.boggiano@seld.be>
*/
class CustomNormalizer extends AbstractNormalizer
class CustomNormalizer extends SerializerAwareNormalizer
{
/**
* {@inheritdoc}
*/
public function normalize($object, $format, $properties = null)
public function normalize($object, $format = null)
{
return $object->normalize($this, $format, $properties);
return $object->normalize($this->serializer, $format);
}
/**
@ -32,7 +32,7 @@ class CustomNormalizer extends AbstractNormalizer
public function denormalize($data, $class, $format = null)
{
$object = new $class;
$object->denormalize($this, $data, $format);
$object->denormalize($this->serializer, $data, $format);
return $object;
}

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

@ -33,15 +33,13 @@ use Symfony\Component\Serializer\SerializerInterface;
*
* @author Nils Adermann <naderman@naderman.de>
*/
class GetSetMethodNormalizer extends AbstractNormalizer
class GetSetMethodNormalizer extends SerializerAwareNormalizer
{
/**
* {@inheritdoc}
*/
public function normalize($object, $format, $properties = null)
public function normalize($object, $format = null)
{
$propertyMap = (null === $properties) ? null : array_flip(array_map('strtolower', $properties));
$reflectionObject = new \ReflectionObject($object);
$reflectionMethods = $reflectionObject->getMethods(\ReflectionMethod::IS_PUBLIC);
@ -50,14 +48,12 @@ class GetSetMethodNormalizer extends AbstractNormalizer
if ($this->isGetMethod($method)) {
$attributeName = strtolower(substr($method->getName(), 3));
if (null === $propertyMap || isset($propertyMap[$attributeName])) {
$attributeValue = $method->invoke($object);
if ($this->serializer->isStructuredType($attributeValue)) {
$attributeValue = $this->serializer->normalize($attributeValue, $format);
}
$attributes[$attributeName] = $attributeValue;
$attributeValue = $method->invoke($object);
if (null !== $attributeValue && !is_scalar($attributeValue)) {
$attributeValue = $this->serializer->normalize($attributeValue, $format);
}
$attributes[$attributeName] = $attributeValue;
}
}

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

@ -2,6 +2,8 @@
namespace Symfony\Component\Serializer\Normalizer;
use Symfony\Component\Serializer\SerializerInterface;
/*
* This file is part of the Symfony framework.
*
@ -27,16 +29,13 @@ interface NormalizableInterface
* It is important to understand that the normalize() call should normalize
* recursively all child objects of the implementor.
*
* @param NormalizerInterface $normalizer The normalizer is given so that you
* can use it to normalize objects contained within this object, eventually
* grabbing the serializer from it to access other normalizers.
* @param SerializerInterface $serializer The serializer is given so that you
* 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|null $properties If provided, this is a (subset) list of
* properties that should be exported from the object.
* @return array|scalar
*/
function normalize(NormalizerInterface $normalizer, $format, $properties = null);
function normalize(SerializerInterface $serializer, $format = null);
/**
* Denormalizes the object back from an array of scalars|arrays.
@ -44,12 +43,11 @@ interface NormalizableInterface
* It is important to understand that the normalize() call should denormalize
* recursively all child objects of the implementor.
*
* @param NormalizerInterface $normalizer The normalizer is given so that you
* can use it to denormalize objects contained within this object, eventually
* grabbing the serializer from it to access other normalizers.
* @param SerializerInterface $serializer The serializer is given so that you
* can use it to denormalize objects contained within this object.
* @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.
*/
function denormalize(NormalizerInterface $normalizer, $data, $format = null);
function denormalize(SerializerInterface $serializer, $data, $format = null);
}

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

@ -25,11 +25,10 @@ interface NormalizerInterface
*
* @param object $object object to normalize
* @param string $format format the normalization result will be encoded as
* @param array $properties a list of properties to extract, if null all properties are returned
* @return array|scalar
* @api
*/
function normalize($object, $format, $properties = null);
function normalize($object, $format = null);
/**
* Denormalizes data back into an object of the given class
@ -62,20 +61,4 @@ interface NormalizerInterface
* @api
*/
function supportsDenormalization($data, $type, $format = null);
/**
* Sets the owning Serializer object
*
* @param SerializerInterface $serializer
* @api
*/
function setSerializer(SerializerInterface $serializer);
/**
* Gets the owning Serializer object
*
* @return SerializerInterface
* @api
*/
function getSerializer();
}

13
src/Symfony/Component/Serializer/Normalizer/AbstractNormalizer.php → src/Symfony/Component/Serializer/Normalizer/SerializerAwareNormalizer.php
View File

@ -3,6 +3,7 @@
namespace Symfony\Component\Serializer\Normalizer;
use Symfony\Component\Serializer\SerializerInterface;
use Symfony\Component\Serializer\SerializerAwareInterface;
/*
* This file is part of the Symfony framework.
@ -14,11 +15,11 @@ use Symfony\Component\Serializer\SerializerInterface;
*/
/**
* Abstract Normalizer implementation
* SerializerAware Normalizer implementation
*
* @author Jordi Boggiano <j.boggiano@seld.be>
*/
abstract class AbstractNormalizer implements NormalizerInterface
abstract class SerializerAwareNormalizer implements SerializerAwareInterface, NormalizerInterface
{
protected $serializer;
@ -29,12 +30,4 @@ abstract class AbstractNormalizer implements NormalizerInterface
{
$this->serializer = $serializer;
}
/**
* {@inheritdoc}
*/
public function getSerializer()
{
return $this->serializer;
}
}

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

@ -4,6 +4,8 @@ namespace Symfony\Component\Serializer;
use Symfony\Component\Serializer\Normalizer\NormalizerInterface;
use Symfony\Component\Serializer\Encoder\EncoderInterface;
use Symfony\Component\Serializer\Encoder\DecoderInterface;
use Symfony\Component\Serializer\Encoder\NormalizationAwareInterface;
/*
* This file is part of the Symfony framework.
@ -30,24 +32,22 @@ class Serializer implements SerializerInterface
{
private $normalizers = array();
private $encoders = array();
private $decoders = array();
protected $normalizerCache = array();
protected $denormalizerCache = array();
/**
* @param mixed $value value to test
* @return Boolean whether the type is a structured type (array + objects)
*/
public function isStructuredType($value)
{
return null !== $value && !is_scalar($value);
}
/**
* {@inheritdoc}
*/
public function serialize($data, $format)
{
return $this->encode($this->normalize($data, $format), $format);
if (!isset($this->encoders[$format])) {
throw new \UnexpectedValueException('No encoder registered for the '.$format.' format');
}
if (!$this->encoders[$format] instanceof NormalizationAwareInterface) {
$data = $this->normalize($data);
}
return $this->encode($data, $format);
}
/**
@ -57,53 +57,12 @@ class Serializer implements SerializerInterface
return $this->denormalize($this->decode($data, $format), $type, $format);
}
/**
* {@inheritdoc}
*/
public function normalizeObject($object, $format, $properties = null)
{
if (!$this->normalizers) {
throw new \LogicException('You must register at least one normalizer to be able to normalize objects.');
}
$class = get_class($object);
if (isset($this->normalizerCache[$class][$format])) {
return $this->normalizerCache[$class][$format]->normalize($object, $format, $properties);
}
foreach ($this->normalizers as $normalizer) {
if ($normalizer->supportsNormalization($object, $class, $format)) {
$this->normalizerCache[$class][$format] = $normalizer;
return $normalizer->normalize($object, $format, $properties);
}
}
throw new \UnexpectedValueException('Could not normalize object of type '.$class.', no supporting normalizer found.');
}
/**
* {@inheritdoc}
*/
public function denormalizeObject($data, $class, $format = null)
{
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);
}
foreach ($this->normalizers as $normalizer) {
if ($normalizer->supportsDenormalization($class, $format)) {
$this->denormalizerCache[$class][$format] = $normalizer;
return $normalizer->denormalize($data, $class, $format);
}
}
throw new \UnexpectedValueException('Could not denormalize object of type '.$class.', no supporting normalizer found.');
}
/**
* {@inheritdoc}
*/
public function normalize($data, $format = null)
{
if (!$this->isStructuredType($data)) {
if (null === $data || is_scalar($data)) {
return $data;
}
if ($data instanceof Traversable) {
@ -138,7 +97,7 @@ class Serializer implements SerializerInterface
*/
public function encode($data, $format)
{
if (!$this->hasEncoder($format)) {
if (!isset($this->encoders[$format])) {
throw new \UnexpectedValueException('No encoder registered for the '.$format.' format');
}
return $this->encoders[$format]->encode($data, $format);
@ -149,23 +108,75 @@ class Serializer implements SerializerInterface
*/
public function decode($data, $format)
{
if (!$this->hasEncoder($format)) {
throw new \UnexpectedValueException('No encoder registered to decode the '.$format.' format');
if (!isset($this->decoders[$format])) {
throw new \UnexpectedValueException('No decoder registered for the '.$format.' format');
}
return $this->encoders[$format]->decode($data, $format);
return $this->decoders[$format]->decode($data, $format);
}
/**
* {@inheritdoc}
* Normalizes an object into a set of arrays/scalars
*
* @param object $object object to normalize
* @param string $format format name, present to give the option to normalizers to act differently based on formats
* @return array|scalar
*/
public function normalizeObject($object, $format = null)
{
if (!$this->normalizers) {
throw new \LogicException('You must register at least one normalizer to be able to normalize objects.');
}
$class = get_class($object);
if (isset($this->normalizerCache[$class][$format])) {
return $this->normalizerCache[$class][$format]->normalize($object, $format);
}
foreach ($this->normalizers as $normalizer) {
if ($normalizer->supportsNormalization($object, $class, $format)) {
$this->normalizerCache[$class][$format] = $normalizer;
return $normalizer->normalize($object, $format);
}
}
throw new \UnexpectedValueException('Could not normalize object of type '.$class.', no supporting normalizer found.');
}
/**
* Denormalizes data back into an object of the given class
*
* @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
* @return object
*/
public function denormalizeObject($data, $class, $format = null)
{
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);
}
foreach ($this->normalizers as $normalizer) {
if ($normalizer->supportsDenormalization($class, $format)) {
$this->denormalizerCache[$class][$format] = $normalizer;
return $normalizer->denormalize($data, $class, $format);
}
}
throw new \UnexpectedValueException('Could not denormalize object of type '.$class.', no supporting normalizer found.');
}
/**
* @param NormalizerInterface $normalizer
*/
public function addNormalizer(NormalizerInterface $normalizer)
{
$this->normalizers[] = $normalizer;
$normalizer->setSerializer($this);
if ($normalizer instanceof SerializerAwareInterface) {
$normalizer->setSerializer($this);
}
}
/**
* {@inheritdoc}
* @return array[]NormalizerInterface
*/
public function getNormalizers()
{
@ -173,7 +184,7 @@ class Serializer implements SerializerInterface
}
/**
* {@inheritdoc}
* @param NormalizerInterface $normalizer
*/
public function removeNormalizer(NormalizerInterface $normalizer)
{
@ -181,16 +192,31 @@ class Serializer implements SerializerInterface
}
/**
* {@inheritdoc}
* @param string $format format name
* @param EncoderInterface $encoder
*/
public function setEncoder($format, EncoderInterface $encoder)
{
$this->encoders[$format] = $encoder;
$encoder->setSerializer($this);
if ($encoder instanceof SerializerAwareInterface) {
$encoder->setSerializer($this);
}
}
/**
* {@inheritdoc}
* @param string $format format name
* @param DecoderInterface $decoder
*/
public function setDecoder($format, DecoderInterface $decoder)
{
$this->decoders[$format] = $decoder;
if ($decoder instanceof SerializerAwareInterface) {
$decoder->setSerializer($this);
}
}
/**
* @return array[]EncoderInterface
*/
public function getEncoders()
{
@ -198,7 +224,15 @@ class Serializer implements SerializerInterface
}
/**
* {@inheritdoc}
* @return array[]DecoderInterface
*/
public function getDecoders()
{
return $this->decoders;
}
/**
* @return EncoderInterface
*/
public function getEncoder($format)
{
@ -206,7 +240,18 @@ class Serializer implements SerializerInterface
}
/**
* {@inheritdoc}
* @return DecoderInterface
*/
public function getDecoder($format)
{
return $this->decoders[$format];
}
/**
* Checks whether the serializer has an encoder registered for the given format
*
* @param string $format format name
* @return Boolean
*/
public function hasEncoder($format)
{
@ -214,10 +259,29 @@ class Serializer implements SerializerInterface
}
/**
* {@inheritdoc}
* Checks whether the serializer has a decoder registered for the given format
*
* @param string $format format name
* @return Boolean
*/
public function hasDecoder($format)
{
return isset($this->decoders[$format]);
}
/**
* @param string $format format name
*/
public function removeEncoder($format)
{
unset($this->encoders[$format]);
}
/**
* @param string $format format name
*/
public function removeDecoder($format)
{
unset($this->decoders[$format]);
}
}

8
src/Symfony/Component/Serializer/SerializerAwareInterface.php
View File

@ -27,12 +27,4 @@ interface SerializerAwareInterface
* @api
*/
function setSerializer(SerializerInterface $serializer);
/**
* Gets the owning Serializer object
*
* @return SerializerInterface
* @api
*/
function getSerializer();
}

6
tests/Symfony/Tests/Component/Serializer/Fixtures/Dummy.php
View File

@ -3,7 +3,7 @@
namespace Symfony\Tests\Component\Serializer\Fixtures;
use Symfony\Component\Serializer\Normalizer\NormalizableInterface;
use Symfony\Component\Serializer\Normalizer\NormalizerInterface;
use Symfony\Component\Serializer\SerializerInterface;
class Dummy implements NormalizableInterface
{
@ -12,7 +12,7 @@ class Dummy implements NormalizableInterface
public $baz;
public $qux;
public function normalize(NormalizerInterface $normalizer, $format, $properties = null)
public function normalize(SerializerInterface $serializer, $format = null)
{
return array(
'foo' => $this->foo,
@ -22,7 +22,7 @@ class Dummy implements NormalizableInterface
);
}
public function denormalize(NormalizerInterface $normalizer, $data, $format = null)
public function denormalize(SerializerInterface $serializer, $data, $format = null)
{
$this->foo = $data['foo'];
$this->bar = $data['bar'];

6
tests/Symfony/Tests/Component/Serializer/Fixtures/ScalarDummy.php
View File

@ -3,19 +3,19 @@
namespace Symfony\Tests\Component\Serializer\Fixtures;
use Symfony\Component\Serializer\Normalizer\NormalizableInterface;
use Symfony\Component\Serializer\Normalizer\NormalizerInterface;
use Symfony\Component\Serializer\SerializerInterface;
class ScalarDummy implements NormalizableInterface
{
public $foo;
public $xmlFoo;
public function normalize(NormalizerInterface $normalizer, $format, $properties = null)
public function normalize(SerializerInterface $serializer, $format = null)
{
return $format === 'xml' ? $this->xmlFoo : $this->foo;
}
public function denormalize(NormalizerInterface $normalizer, $data, $format = null)
public function denormalize(SerializerInterface $serializer, $data, $format = null)
{
if ($format === 'xml') {
$this->xmlFoo = $data;

3
tests/Symfony/Tests/Component/Serializer/Normalizer/CustomNormalizerTest.php
View File

@ -6,6 +6,7 @@ require_once __DIR__.'/../Fixtures/ScalarDummy.php';
use Symfony\Tests\Component\Serializer\Fixtures\ScalarDummy;
use Symfony\Component\Serializer\Normalizer\CustomNormalizer;
use Symfony\Component\Serializer\Serializer;
/*
* This file is part of the Symfony framework.
@ -21,7 +22,7 @@ class CustomNormalizerTest extends \PHPUnit_Framework_TestCase
public function setUp()
{
$this->normalizer = new CustomNormalizer;
$this->normalizer->setSerializer($this->getMock('Symfony\Component\Serializer\Serializer'));
$this->normalizer->setSerializer(new Serializer);
}
public function testSerialize()

11
tests/Symfony/Tests/Component/Serializer/Normalizer/GetSetMethodNormalizerTest.php
View File

@ -33,17 +33,6 @@ class GetSetMethodNormalizerTest extends \PHPUnit_Framework_TestCase
);
}
public function testNormalizeRestricted()
{
$obj = new GetSetDummy;
$obj->setFoo('foo');
$obj->setBar('bar');
$this->assertEquals(
array('foo' => 'foo'),
$this->normalizer->normalize($obj, 'any', array('foo'))
);
}
public function testDenormalize()
{
$obj = $this->normalizer->denormalize(

2
tests/Symfony/Tests/Component/Serializer/SerializerTest.php
View File

@ -65,7 +65,7 @@ class SerializerTest extends \PHPUnit_Framework_TestCase
public function testDecode()
{
$this->serializer->setEncoder('json', new JsonEncoder());
$this->serializer->setDecoder('json', new JsonEncoder());
$data = array('foo', array(5, 3));
$result = $this->serializer->decode(json_encode($data), 'json');
$this->assertEquals($data, $result);