bug symfony#17199 [Serializer] Allow context to contain not serializable data (dunglas, nicolas-grekas)

This PR was merged into the 2.8 branch.

Discussion
----------

[Serializer] Allow context to contain not serializable data

| Q             | A
| ------------- | ---
| Bug fix?      | yes
| New feature?  | no
| BC breaks?    | no
| Deprecations? | no
| Tests pass?   | yes
| Fixed tickets | n/a
| License       | MIT
| Doc PR        | n/a

Allow the context to contain not serializable data even for the `ObjectNormalizer` (BC break fix).

Commits
-------

996f69d Merge pull request #2 from nicolas-grekas/ser-cache
8560c13 [Serializer] Use $context['cache_key'] to enhance caching
c1740fc [Serializer] ObjectNormalizer: context can contain not serializable data

Author: fabpot

src/Symfony/Component/Serializer/Normalizer/ObjectNormalizer.php

@@ -26,7 +26,7 @@
  */
 class ObjectNormalizer extends AbstractNormalizer
 {
-    private static $attributesCache = array();
+    private $attributesCache = array();
 
     /**
      * @var PropertyAccessorInterface
@@ -55,6 +55,9 @@ public function supportsNormalization($data, $format = null)
      */
     public function normalize($object, $format = null, array $context = array())
     {
+        if (!isset($context['cache_key'])) {
+            $context['cache_key'] = $this->getCacheKey($context);
+        }
         if ($this->isCircularReference($object, $context)) {
             return $this->handleCircularReference($object);
         }
@@ -104,6 +107,9 @@ public function supportsDenormalization($data, $type, $format = null)
      */
     public function denormalize($data, $class, $format = null, array $context = array())
     {
+        if (!isset($context['cache_key'])) {
+            $context['cache_key'] = $this->getCacheKey($context);
+        }
         $allowedAttributes = $this->getAllowedAttributes($class, $context, true);
         $normalizedData = $this->prepareForDenormalization($data);
 
@@ -130,28 +136,59 @@ public function denormalize($data, $class, $format = null, array $context = arra
         return $object;
     }
 
+    private function getCacheKey(array $context)
+    {
+        try {
+            return md5(serialize($context));
+        } catch (\Exception $exception) {
+            // The context cannot be serialized, skip the cache
+            return false;
+        }
+    }
+
     /**
      * Gets and caches attributes for this class and context.
      *
      * @param object $object
      * @param array  $context
      *
-     * @return array
+     * @return string[]
      */
     private function getAttributes($object, array $context)
     {
-        $key = sprintf('%s-%s', get_class($object), serialize($context));
+        $class = get_class($object);
+        $key = $class.'-'.$context['cache_key'];
 
-        if (isset(self::$attributesCache[$key])) {
-            return self::$attributesCache[$key];
+        if (isset($this->attributesCache[$key])) {
+            return $this->attributesCache[$key];
         }
 
         $allowedAttributes = $this->getAllowedAttributes($object, $context, true);
 
         if (false !== $allowedAttributes) {
-            return self::$attributesCache[$key] = $allowedAttributes;
+            if ($context['cache_key']) {
+                $this->attributesCache[$key] = $allowedAttributes;
+            }
+
+            return $allowedAttributes;
+        }
+
+        if (isset($this->attributesCache[$class])) {
+            return $this->attributesCache[$class];
         }
 
+        return $this->attributesCache[$class] = $this->extractAttributes($object);
+    }
+
+    /**
+     * Extracts attributes for this class and context.
+     *
+     * @param object $object
+     *
+     * @return string[]
+     */
+    private function extractAttributes($object)
+    {
         // If not using groups, detect manually
         $attributes = array();
 
@@ -167,9 +204,9 @@ private function getAttributes($object, array $context)
                 continue;
             }
 
-            $name = $reflMethod->getName();
+            $name = $reflMethod->name;
 
-            if (strpos($name, 'get') === 0 || strpos($name, 'has') === 0) {
+            if (0 === strpos($name, 'get') || 0 === strpos($name, 'has')) {
                 // getters and hassers
                 $attributes[lcfirst(substr($name, 3))] = true;
             } elseif (strpos($name, 'is') === 0) {
@@ -184,9 +221,9 @@ private function getAttributes($object, array $context)
                 continue;
             }
 
-            $attributes[$reflProperty->getName()] = true;
+            $attributes[$reflProperty->name] = true;
         }
 
-        return self::$attributesCache[$key] = array_keys($attributes);
+        return array_keys($attributes);
     }
 }

src/Symfony/Component/Serializer/Tests/Normalizer/ObjectNormalizerTest.php

@@ -473,6 +473,21 @@ public function testNormalizeStatic()
     {
         $this->assertEquals(array('foo' => 'K'), $this->normalizer->normalize(new ObjectWithStaticPropertiesAndMethods()));
     }
+
+    public function testNormalizeNotSerializableContext()
+    {
+        $objectDummy = new ObjectDummy();
+        $expected = array(
+            'foo' => null,
+            'baz' => null,
+            'fooBar' => '',
+            'camelCase' => null,
+            'object' => null,
+            'bar' => null,
+        );
+
+        $this->assertEquals($expected, $this->normalizer->normalize($objectDummy, null, array('not_serializable' => function () {})));
+    }
 }
 
 class ObjectDummy