Merge branch '4.4' into 5.0

fabpot · fabpot · commit 2b1897dee37d · 2020-03-16T13:10:54.000+01:00
* 4.4:
  Fix quotes in exception messages
  Fix quotes in exception messages
  Fix quotes in exception messages
diff --git a/Encoder/XmlEncoder.php b/Encoder/XmlEncoder.php
@@ -409,7 +409,7 @@ private function buildXml(\DOMNode $parentNode, $data, string $xmlRootNodeName =
 
         if (\is_object($data)) {
             if (null === $this->serializer) {
-                throw new BadMethodCallException(sprintf('The serializer needs to be set to allow %s() to be used with object data.', __METHOD__));
+                throw new BadMethodCallException(sprintf('The serializer needs to be set to allow "%s()" to be used with object data.', __METHOD__));
             }
 
             $data = $this->serializer->normalize($data, $this->format, $this->context);
@@ -475,7 +475,7 @@ private function selectNodeType(\DOMNode $node, $val): bool
             $this->buildXml($node, $val);
         } elseif (\is_object($val)) {
             if (null === $this->serializer) {
-                throw new BadMethodCallException(sprintf('The serializer needs to be set to allow %s() to be used with object data.', __METHOD__));
+                throw new BadMethodCallException(sprintf('The serializer needs to be set to allow "%s()" to be used with object data.', __METHOD__));
             }
 
             return $this->selectNodeType($node, $this->serializer->normalize($val, $this->format, $this->context));
diff --git a/Mapping/Loader/FileLoader.php b/Mapping/Loader/FileLoader.php
@@ -30,11 +30,11 @@ abstract class FileLoader implements LoaderInterface
     public function __construct(string $file)
     {
         if (!is_file($file)) {
-            throw new MappingException(sprintf('The mapping file %s does not exist.', $file));
+            throw new MappingException(sprintf('The mapping file "%s" does not exist.', $file));
         }
 
         if (!is_readable($file)) {
-            throw new MappingException(sprintf('The mapping file %s is not readable.', $file));
+            throw new MappingException(sprintf('The mapping file "%s" is not readable.', $file));
         }
 
         $this->file = $file;
diff --git a/Mapping/Loader/LoaderChain.php b/Mapping/Loader/LoaderChain.php
@@ -40,7 +40,7 @@ public function __construct(array $loaders)
     {
         foreach ($loaders as $loader) {
             if (!$loader instanceof LoaderInterface) {
-                throw new MappingException(sprintf('Class %s is expected to implement LoaderInterface.', \get_class($loader)));
+                throw new MappingException(sprintf('Class "%s" is expected to implement LoaderInterface.', \get_class($loader)));
             }
         }
 
diff --git a/Normalizer/AbstractNormalizer.php b/Normalizer/AbstractNormalizer.php
@@ -354,7 +354,7 @@ protected function instantiateObject(array &$data, string $class, array &$contex
                 if ($constructorParameter->isVariadic()) {
                     if ($allowed && !$ignored && (isset($data[$key]) || \array_key_exists($key, $data))) {
                         if (!\is_array($data[$paramName])) {
-                            throw new RuntimeException(sprintf('Cannot create an instance of %s from serialized data because the variadic parameter %s can only accept an array.', $class, $constructorParameter->name));
+                            throw new RuntimeException(sprintf('Cannot create an instance of "%s" from serialized data because the variadic parameter "%s" can only accept an array.', $class, $constructorParameter->name));
                         }
 
                         $variadicParameters = [];
@@ -384,7 +384,7 @@ protected function instantiateObject(array &$data, string $class, array &$contex
                 } elseif ($constructorParameter->isDefaultValueAvailable()) {
                     $params[] = $constructorParameter->getDefaultValue();
                 } else {
-                    throw new MissingConstructorArgumentsException(sprintf('Cannot create an instance of %s from serialized data because its constructor requires parameter "%s" to be present.', $class, $constructorParameter->name));
+                    throw new MissingConstructorArgumentsException(sprintf('Cannot create an instance of "%s" from serialized data because its constructor requires parameter "%s" to be present.', $class, $constructorParameter->name));
                 }
             }
 
@@ -406,7 +406,7 @@ protected function denormalizeParameter(\ReflectionClass $class, \ReflectionPara
         try {
             if (null !== $parameter->getClass()) {
                 if (!$this->serializer instanceof DenormalizerInterface) {
-                    throw new LogicException(sprintf('Cannot create an instance of %s from serialized data because the serializer inject in "%s" is not a denormalizer.', $parameter->getClass(), self::class));
+                    throw new LogicException(sprintf('Cannot create an instance of "%s" from serialized data because the serializer inject in "%s" is not a denormalizer.', $parameter->getClass(), self::class));
                 }
                 $parameterClass = $parameter->getClass()->getName();
                 $parameterData = $this->serializer->denormalize($parameterData, $parameterClass, $format, $this->createChildContext($context, $parameterName, $format));
diff --git a/Normalizer/ArrayDenormalizer.php b/Normalizer/ArrayDenormalizer.php
@@ -69,7 +69,7 @@ public function denormalize($data, string $type, string $format = null, array $c
     public function supportsDenormalization($data, string $type, string $format = null, array $context = []): bool
     {
         if (null === $this->serializer) {
-            throw new BadMethodCallException(sprintf('The serializer needs to be set to allow %s() to be used.', __METHOD__));
+            throw new BadMethodCallException(sprintf('The serializer needs to be set to allow "%s()" to be used.', __METHOD__));
         }
 
         return '[]' === substr($type, -2)
diff --git a/Normalizer/DateIntervalNormalizer.php b/Normalizer/DateIntervalNormalizer.php
@@ -72,7 +72,7 @@ public function hasCacheableSupportsMethod(): bool
     public function denormalize($data, string $type, string $format = null, array $context = [])
     {
         if (!\is_string($data)) {
-            throw new InvalidArgumentException(sprintf('Data expected to be a string, %s given.', \gettype($data)));
+            throw new InvalidArgumentException(sprintf('Data expected to be a string, "%s" given.', \gettype($data)));
         }
 
         if (!$this->isISO8601($data)) {
diff --git a/Serializer.php b/Serializer.php
@@ -112,7 +112,7 @@ public function __construct(array $normalizers = [], array $encoders = [])
     final public function serialize($data, string $format, array $context = []): string
     {
         if (!$this->supportsEncoding($format, $context)) {
-            throw new NotEncodableValueException(sprintf('Serialization for the format %s is not supported.', $format));
+            throw new NotEncodableValueException(sprintf('Serialization for the format "%s" is not supported.', $format));
         }
 
         if ($this->encoder->needsNormalization($format, $context)) {
@@ -128,7 +128,7 @@ final public function serialize($data, string $format, array $context = []): str
     final public function deserialize($data, string $type, string $format, array $context = [])
     {
         if (!$this->supportsDecoding($format, $context)) {
-            throw new NotEncodableValueException(sprintf('Deserialization for the format %s is not supported.', $format));
+            throw new NotEncodableValueException(sprintf('Deserialization for the format "%s" is not supported.', $format));
         }
 
         $data = $this->decode($data, $format, $context);
@@ -164,7 +164,7 @@ public function normalize($data, string $format = null, array $context = [])
                 throw new LogicException('You must register at least one normalizer to be able to normalize objects.');
             }
 
-            throw new NotNormalizableValueException(sprintf('Could not normalize object of type %s, no supporting normalizer found.', \get_class($data)));
+            throw new NotNormalizableValueException(sprintf('Could not normalize object of type "%s", no supporting normalizer found.', \get_class($data)));
         }
 
         throw new NotNormalizableValueException(sprintf('An unexpected value could not be normalized: %s.', !\is_resource($data) ? var_export($data, true) : sprintf('%s resource', get_resource_type($data))));
@@ -185,7 +185,7 @@ public function denormalize($data, string $type, string $format = null, array $c
             return $normalizer->denormalize($data, $type, $format, $context);
         }
 
-        throw new NotNormalizableValueException(sprintf('Could not denormalize object of type %s, no supporting normalizer found.', $type));
+        throw new NotNormalizableValueException(sprintf('Could not denormalize object of type "%s", no supporting normalizer found.', $type));
     }
 
     /**
diff --git a/Tests/Normalizer/Features/ConstructorArgumentsTestTrait.php b/Tests/Normalizer/Features/ConstructorArgumentsTestTrait.php
@@ -55,7 +55,7 @@ public function testConstructorWithMissingData()
         $normalizer = $this->getDenormalizerForConstructArguments();
 
         $this->expectException(MissingConstructorArgumentsException::class);
-        $this->expectExceptionMessage('Cannot create an instance of '.ConstructorArgumentsObject::class.' from serialized data because its constructor requires parameter "bar" to be present.');
+        $this->expectExceptionMessage('Cannot create an instance of "'.ConstructorArgumentsObject::class.'" from serialized data because its constructor requires parameter "bar" to be present.');
         $normalizer->denormalize($data, ConstructorArgumentsObject::class);
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -409,7 +409,7 @@ private function buildXml(\DOMNode $parentNode, $data, string $xmlRootNodeName =`
`409`	`409`
`410`	`410`	`if (\is_object($data)) {`
`411`	`411`	`if (null === $this->serializer) {`
`412`		`- throw new BadMethodCallException(sprintf('The serializer needs to be set to allow %s() to be used with object data.', __METHOD__));`
	`412`	`+ throw new BadMethodCallException(sprintf('The serializer needs to be set to allow "%s()" to be used with object data.', __METHOD__));`
`413`	`413`	`}`
`414`	`414`
`415`	`415`	`$data = $this->serializer->normalize($data, $this->format, $this->context);`
`@@ -475,7 +475,7 @@ private function selectNodeType(\DOMNode $node, $val): bool`
`475`	`475`	`$this->buildXml($node, $val);`
`476`	`476`	`} elseif (\is_object($val)) {`
`477`	`477`	`if (null === $this->serializer) {`
`478`		`- throw new BadMethodCallException(sprintf('The serializer needs to be set to allow %s() to be used with object data.', __METHOD__));`
	`478`	`+ throw new BadMethodCallException(sprintf('The serializer needs to be set to allow "%s()" to be used with object data.', __METHOD__));`
`479`	`479`	`}`
`480`	`480`
`481`	`481`	`return $this->selectNodeType($node, $this->serializer->normalize($val, $this->format, $this->context));`
Original file line number	Diff line number	Diff line change
`@@ -30,11 +30,11 @@ abstract class FileLoader implements LoaderInterface`
`30`	`30`	`public function __construct(string $file)`
`31`	`31`	`{`
`32`	`32`	`if (!is_file($file)) {`
`33`		`- throw new MappingException(sprintf('The mapping file %s does not exist.', $file));`
	`33`	`+ throw new MappingException(sprintf('The mapping file "%s" does not exist.', $file));`
`34`	`34`	`}`
`35`	`35`
`36`	`36`	`if (!is_readable($file)) {`
`37`		`- throw new MappingException(sprintf('The mapping file %s is not readable.', $file));`
	`37`	`+ throw new MappingException(sprintf('The mapping file "%s" is not readable.', $file));`
`38`	`38`	`}`
`39`	`39`
`40`	`40`	`$this->file = $file;`
Original file line number	Diff line number	Diff line change
`@@ -40,7 +40,7 @@ public function __construct(array $loaders)`
`40`	`40`	`{`
`41`	`41`	`foreach ($loaders as $loader) {`
`42`	`42`	`if (!$loader instanceof LoaderInterface) {`
`43`		`- throw new MappingException(sprintf('Class %s is expected to implement LoaderInterface.', \get_class($loader)));`
	`43`	`+ throw new MappingException(sprintf('Class "%s" is expected to implement LoaderInterface.', \get_class($loader)));`
`44`	`44`	`}`
`45`	`45`	`}`
`46`	`46`
Original file line number	Diff line number	Diff line change
`@@ -354,7 +354,7 @@ protected function instantiateObject(array &$data, string $class, array &$contex`
`354`	`354`	`if ($constructorParameter->isVariadic()) {`
`355`	`355`	`if ($allowed && !$ignored && (isset($data[$key]) \|\| \array_key_exists($key, $data))) {`
`356`	`356`	`if (!\is_array($data[$paramName])) {`
`357`		`- throw new RuntimeException(sprintf('Cannot create an instance of %s from serialized data because the variadic parameter %s can only accept an array.', $class, $constructorParameter->name));`
	`357`	`+ throw new RuntimeException(sprintf('Cannot create an instance of "%s" from serialized data because the variadic parameter "%s" can only accept an array.', $class, $constructorParameter->name));`
`358`	`358`	`}`
`359`	`359`
`360`	`360`	`$variadicParameters = [];`
`@@ -384,7 +384,7 @@ protected function instantiateObject(array &$data, string $class, array &$contex`
`384`	`384`	`} elseif ($constructorParameter->isDefaultValueAvailable()) {`
`385`	`385`	`$params[] = $constructorParameter->getDefaultValue();`
`386`	`386`	`} else {`
`387`		`- throw new MissingConstructorArgumentsException(sprintf('Cannot create an instance of %s from serialized data because its constructor requires parameter "%s" to be present.', $class, $constructorParameter->name));`
	`387`	`+ throw new MissingConstructorArgumentsException(sprintf('Cannot create an instance of "%s" from serialized data because its constructor requires parameter "%s" to be present.', $class, $constructorParameter->name));`
`388`	`388`	`}`
`389`	`389`	`}`
`390`	`390`
`@@ -406,7 +406,7 @@ protected function denormalizeParameter(\ReflectionClass $class, \ReflectionPara`
`406`	`406`	`try {`
`407`	`407`	`if (null !== $parameter->getClass()) {`
`408`	`408`	`if (!$this->serializer instanceof DenormalizerInterface) {`
`409`		`- throw new LogicException(sprintf('Cannot create an instance of %s from serialized data because the serializer inject in "%s" is not a denormalizer.', $parameter->getClass(), self::class));`
	`409`	`+ throw new LogicException(sprintf('Cannot create an instance of "%s" from serialized data because the serializer inject in "%s" is not a denormalizer.', $parameter->getClass(), self::class));`
`410`	`410`	`}`
`411`	`411`	`$parameterClass = $parameter->getClass()->getName();`
`412`	`412`	`$parameterData = $this->serializer->denormalize($parameterData, $parameterClass, $format, $this->createChildContext($context, $parameterName, $format));`
Original file line number	Diff line number	Diff line change
`@@ -69,7 +69,7 @@ public function denormalize($data, string $type, string $format = null, array $c`
`69`	`69`	`public function supportsDenormalization($data, string $type, string $format = null, array $context = []): bool`
`70`	`70`	`{`
`71`	`71`	`if (null === $this->serializer) {`
`72`		`- throw new BadMethodCallException(sprintf('The serializer needs to be set to allow %s() to be used.', __METHOD__));`
	`72`	`+ throw new BadMethodCallException(sprintf('The serializer needs to be set to allow "%s()" to be used.', __METHOD__));`
`73`	`73`	`}`
`74`	`74`
`75`	`75`	`return '[]' === substr($type, -2)`
Original file line number	Diff line number	Diff line change
`@@ -72,7 +72,7 @@ public function hasCacheableSupportsMethod(): bool`
`72`	`72`	`public function denormalize($data, string $type, string $format = null, array $context = [])`
`73`	`73`	`{`
`74`	`74`	`if (!\is_string($data)) {`
`75`		`- throw new InvalidArgumentException(sprintf('Data expected to be a string, %s given.', \gettype($data)));`
	`75`	`+ throw new InvalidArgumentException(sprintf('Data expected to be a string, "%s" given.', \gettype($data)));`
`76`	`76`	`}`
`77`	`77`
`78`	`78`	`if (!$this->isISO8601($data)) {`
Original file line number	Diff line number	Diff line change
`@@ -112,7 +112,7 @@ public function __construct(array $normalizers = [], array $encoders = [])`
`112`	`112`	`final public function serialize($data, string $format, array $context = []): string`
`113`	`113`	`{`
`114`	`114`	`if (!$this->supportsEncoding($format, $context)) {`
`115`		`- throw new NotEncodableValueException(sprintf('Serialization for the format %s is not supported.', $format));`
	`115`	`+ throw new NotEncodableValueException(sprintf('Serialization for the format "%s" is not supported.', $format));`
`116`	`116`	`}`
`117`	`117`
`118`	`118`	`if ($this->encoder->needsNormalization($format, $context)) {`
`@@ -128,7 +128,7 @@ final public function serialize($data, string $format, array $context = []): str`
`128`	`128`	`final public function deserialize($data, string $type, string $format, array $context = [])`
`129`	`129`	`{`
`130`	`130`	`if (!$this->supportsDecoding($format, $context)) {`
`131`		`- throw new NotEncodableValueException(sprintf('Deserialization for the format %s is not supported.', $format));`
	`131`	`+ throw new NotEncodableValueException(sprintf('Deserialization for the format "%s" is not supported.', $format));`
`132`	`132`	`}`
`133`	`133`
`134`	`134`	`$data = $this->decode($data, $format, $context);`
`@@ -164,7 +164,7 @@ public function normalize($data, string $format = null, array $context = [])`
`164`	`164`	`throw new LogicException('You must register at least one normalizer to be able to normalize objects.');`
`165`	`165`	`}`
`166`	`166`
`167`		`- throw new NotNormalizableValueException(sprintf('Could not normalize object of type %s, no supporting normalizer found.', \get_class($data)));`
	`167`	`+ throw new NotNormalizableValueException(sprintf('Could not normalize object of type "%s", no supporting normalizer found.', \get_class($data)));`
`168`	`168`	`}`
`169`	`169`
`170`	`170`	`throw new NotNormalizableValueException(sprintf('An unexpected value could not be normalized: %s.', !\is_resource($data) ? var_export($data, true) : sprintf('%s resource', get_resource_type($data))));`
`@@ -185,7 +185,7 @@ public function denormalize($data, string $type, string $format = null, array $c`
`185`	`185`	`return $normalizer->denormalize($data, $type, $format, $context);`
`186`	`186`	`}`
`187`	`187`
`188`		`- throw new NotNormalizableValueException(sprintf('Could not denormalize object of type %s, no supporting normalizer found.', $type));`
	`188`	`+ throw new NotNormalizableValueException(sprintf('Could not denormalize object of type "%s", no supporting normalizer found.', $type));`
`189`	`189`	`}`
`190`	`190`
`191`	`191`	`/**`
Original file line number	Diff line number	Diff line change
`@@ -55,7 +55,7 @@ public function testConstructorWithMissingData()`
`55`	`55`	`$normalizer = $this->getDenormalizerForConstructArguments();`
`56`	`56`
`57`	`57`	`$this->expectException(MissingConstructorArgumentsException::class);`
`58`		`- $this->expectExceptionMessage('Cannot create an instance of '.ConstructorArgumentsObject::class.' from serialized data because its constructor requires parameter "bar" to be present.');`
	`58`	`+ $this->expectExceptionMessage('Cannot create an instance of "'.ConstructorArgumentsObject::class.'" from serialized data because its constructor requires parameter "bar" to be present.');`
`59`	`59`	`$normalizer->denormalize($data, ConstructorArgumentsObject::class);`
`60`	`60`	`}`
`61`	`61`	`}`